[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[elpa] master 9014381: Release ada-mode 7.0.1, wisi 3.0.1
|
From: |
Stephen Leake |
|
Subject: |
[elpa] master 9014381: Release ada-mode 7.0.1, wisi 3.0.1 |
|
Date: |
Thu, 30 Jan 2020 08:38:12 -0500 (EST) |
branch: master
commit 90143815a5a8f44c5509f54617cdadb1ef810966
Author: Stephen Leake <address@hidden>
Commit: Stephen Leake <address@hidden>
Release ada-mode 7.0.1, wisi 3.0.1
---
packages/ada-mode/NEWS | 49 +-
packages/ada-mode/README | 45 +-
packages/ada-mode/ada-build.el | 223 +-
.../{ada-gnat-compile.el => ada-compiler-gnat.el} | 280 +-
packages/ada-mode/ada-core.el | 762 +
packages/ada-mode/ada-fix-error.el | 237 -
packages/ada-mode/ada-gnat-xref.el | 210 +-
packages/ada-mode/ada-imenu.el | 4 +-
packages/ada-mode/ada-indent-user-options.el | 69 +-
packages/ada-mode/ada-mode-compat.el | 27 -
packages/ada-mode/ada-mode.el | 2827 +-
packages/ada-mode/ada-mode.info | 1121 +-
packages/ada-mode/ada-mode.texi | 1013 +-
packages/ada-mode/ada-prj.el | 4 -
packages/ada-mode/ada-process.el | 2 +
packages/ada-mode/ada-project.el | 120 -
packages/ada-mode/ada-skel.el | 143 +-
packages/ada-mode/ada-stmt.el | 4 -
packages/ada-mode/ada-wisi.el | 795 -
packages/ada-mode/ada-xref.el | 5 -
packages/ada-mode/ada.wy | 928 +-
packages/ada-mode/ada_lr1_parse_table.txt.gz | Bin 3170831 -> 3555116
bytes
packages/ada-mode/ada_mode_wisi_parse.gpr.gp | 23 +-
packages/ada-mode/ada_process_actions.adb | 76 +-
packages/ada-mode/ada_process_actions.ads | 28 +-
packages/ada-mode/ada_process_lalr_main.adb | 29496 ++++++++++---------
packages/ada-mode/ada_process_lr1_main.adb | 715 +-
packages/ada-mode/ada_re2c.c | 3752 +--
packages/ada-mode/build.sh | 15 +-
packages/ada-mode/dir | 8 +-
packages/ada-mode/gnat-core.el | 602 +-
packages/ada-mode/gpr-indent-user-options.el | 8 +-
packages/ada-mode/gpr-mode.el | 328 +-
packages/ada-mode/gpr-mode.info | 95 +-
packages/ada-mode/gpr-mode.texi | 88 +-
packages/ada-mode/gpr-process.el | 1 +
packages/ada-mode/gpr-query.el | 1497 +-
packages/ada-mode/gpr-skel.el | 154 +-
packages/ada-mode/gpr-wisi.el | 133 -
packages/ada-mode/gpr.wy | 8 +-
packages/ada-mode/gpr_process_actions.adb | 16 +-
packages/ada-mode/gpr_query.adb | 429 +-
packages/ada-mode/gpr_query.gpr.gp | 73 -
packages/ada-mode/gpr_re2c.c | 198 +-
packages/ada-mode/install.sh | 15 +
packages/ada-mode/wisi-ada.adb | 75 +-
packages/ada-mode/wisi-ada.ads | 11 +-
packages/{wisi/wisi.gpr => ada-mode/wisi.gpr.gp} | 7 +-
.../wisitoken-parse-lr-mckenzie_recover-ada.adb | 36 +-
packages/ada-mode/xref-ada.el | 79 -
packages/wisi/NEWS | 28 +-
packages/wisi/README | 9 +-
packages/wisi/build-wisitoken-bnf-generate.sh | 2 +-
packages/wisi/emacs_wisi_common_parse.adb | 8 +-
packages/wisi/emacs_wisi_common_parse.ads | 5 +-
packages/wisi/recover_stats.adb | 277 +
packages/wisi/run_wisi_common_parse.adb | 8 +-
packages/wisi/wisi-fringe.el | 302 +-
packages/wisi/wisi-parse-common.el | 7 +-
packages/wisi/wisi-prj.el | 1466 +
packages/wisi/wisi-process-parse.el | 18 +-
packages/wisi/wisi-run-indent-test.el | 67 +-
packages/wisi/wisi-skel.el | 154 +
packages/wisi/wisi.adb | 94 +-
packages/wisi/wisi.ads | 65 +-
packages/wisi/wisi.el | 456 +-
packages/wisi/{wisi.gpr => wisi.gpr.gp} | 7 +-
packages/wisi/wisitoken-bnf-generate.adb | 2 +-
packages/wisi/wisitoken-bnf-output_ada_common.adb | 32 +-
...wisitoken-parse-lr-mckenzie_recover-explore.adb | 12 +-
.../wisi/wisitoken-parse-lr-mckenzie_recover.adb | 43 +-
.../wisi/wisitoken-parse-lr-mckenzie_recover.ads | 15 +-
packages/wisi/wisitoken-parse-lr-parser.adb | 21 +-
packages/wisi/wisitoken-parse-lr-parser.ads | 2 +
packages/wisi/wisitoken-parse-lr.ads | 3 +-
packages/wisi/wisitoken-parse.adb | 9 +-
packages/wisi/wisitoken-parse.ads | 17 +-
packages/wisi/wisitoken-semantic_checks.ads | 3 +-
packages/wisi/wisitoken_grammar_re2c.c | 186 +-
79 files changed, 25458 insertions(+), 24694 deletions(-)
diff --git a/packages/ada-mode/NEWS b/packages/ada-mode/NEWS
index 22a55ff..944a7dd 100644
--- a/packages/ada-mode/NEWS
+++ b/packages/ada-mode/NEWS
@@ -1,11 +1,58 @@
GNU Emacs Ada mode NEWS -- history of user-visible changes.
-Copyright (C) 2019 Free Software Foundation, Inc.
+Copyright (C) 2014 - 2020 Free Software Foundation, Inc.
Please send ada-mode bug reports to address@hidden, with
'ada-mode' in the subject. If possible, use M-x report-emacs-bug.
+* Ada Mode 7.0.1
+30 Jan 2020
+
+** fix packaging bugs
+
+** build.sh is now split into build.sh and install.sh; the latter
+ takes --prefix and may need to be run as root.
+
+** improve xref integration
+
+* Ada Mode 7.0.0
+19 Dec 2019
+
+** parser Ada language protocol version 3
+
+** Added support for the Ada 2020 features
+ iterated_component_association (ai12-0061), target_name
+ (ai12-0125), delta_aggregate (ai12-0127); these are supported in
+ GNAT Community 2019.
+
+** Major restructuring of code, moving many functions from ada-mode to
+ wisi for use in other language modes, and using cl-defgeneric
+ dispatching instead of function variables. Normal users should see
+ no changes, except that some ada-mode functions will warn about
+ being obsolete. If you've written custom code that depends on
+ ada-mode functions, you may have to change it.
+
+** gpr-mode fully supports auto-casing; new user variables
+ gpr-auto-case, gpr-case-keyword, gpr-case-strict,
+ gpr-case-identifier, respects 'casing' project file settings.
+
+** New commands `wisi-goto-containing-statement-start',
+ `wisi-indent-containing-statement' are in the menu.
+ `wisi-indent-containing-statement' is bound to 'C-c S-i'.
+
+** `ada-goto-declarative-region-start' now goes to the containing
+ region, when the start point is before the 'is' in the current
+ declaration (previously, it went to the declarative region of the
+ current declaration). This is required for adding a use_clause for
+ an identifier/operator in a format_part or aspect_clause.
+
+** Delete not-upper-case setting for ada-auto-case; instead, set
+ ada-case-strict to nil.
+
+** wisi-prj-identifier-at-point (previously ada-identifier-at-point)
+ now handles non-ASCII characters.
+
* Ada Mode 6.2.1
17 Aug 2019
diff --git a/packages/ada-mode/README b/packages/ada-mode/README
index 7cec70d..ec8c774 100644
--- a/packages/ada-mode/README
+++ b/packages/ada-mode/README
@@ -1,15 +1,31 @@
-Emacs Ada mode version 6.2.1
+Emacs Ada mode version 7.0.1
Ada mode provides auto-casing, fontification, navigation, and
indentation for Ada source code files.
Cross-reference information output by the compiler is used to provide
-powerful code navigation (jump to definition, find all uses, etc). By
-default, only the AdaCore GNAT compiler is supported; other compilers
-can be supported. Ada mode uses gpr_query to query compiler-generated
-cross reference information. gpr_query is provided as Ada source code
-that must be compiled and installed; see ada-mode.info section
-Installation for instructions.
+powerful code navigation (jump to definition, find all uses, show
+overriding, etc). By default, only the AdaCore GNAT compiler is
+supported; other compilers can be supported. Ada mode uses gpr_query
+to query compiler-generated cross reference information.
+
+Ada mode uses a parser to provide fontification, navigation, and
+indentation. The parser is implemented in Ada, is fast enough even for very
+large files (via partial parsing), and recovers from almost all syntax
+errors.
+
+gpr_query and the parser are provided as Ada source code that must be
+compiled and installed:
+
+cd ~/.emacs.d/elpa/ada-mode-i.j.k
+./build.sh
+./install.sh
+
+install.sh can take an option "--prefix=<dir>" to set the installation
+directory.
+
+See ada-mode.info section Installation for more information on
+installing; you may need additional packages.
Ada mode will be automatically loaded when you open a file
with a matching extension (default *.ads, *.adb).
@@ -17,18 +33,5 @@ with a matching extension (default *.ads, *.adb).
Ada mode uses project files to define large (multi-directory)
projects, and to define casing exceptions.
-Ada mode uses a parser to provide fontification, navigation, and
-indentation. There are two parsers provided:
-
-- elisp, which can be slow on large files, and does not recover from
- syntax errors.
-
-- process, which is implemented in Ada, is fast enough for reasonably
- large files, supports partial parse for very large files (see
- wisi-partial-parse-threshold), and recovers from almost all syntax
- errors. The 'process' parser must be compiled; see ada-mode.info
- section "process parser".
-
-See ada-mode.info for help on using and customizing Ada mode, and
-notes for Ada mode developers.
+See ada-mode.info for help on using and customizing Ada mode.
diff --git a/packages/ada-mode/ada-build.el b/packages/ada-mode/ada-build.el
index b978040..7d12dbf 100644
--- a/packages/ada-mode/ada-build.el
+++ b/packages/ada-mode/ada-build.el
@@ -34,7 +34,8 @@
;; compiling and running capabilities in Ada mode 4.01, done in 2013 by
;; Stephen Leake <address@hidden>.
-(require 'ada-mode)
+(require 'ada-core)
+(require 'gnat-core)
(require 'cl-lib)
;;;; User customization
@@ -44,10 +45,11 @@
:group 'ada)
(defcustom ada-build-prompt-prj 'default
- "Policy for finding a project file when none is currently selected."
+ "Policy for finding a project file when none is currently selected.
+See `ada-build-require-project-file'."
:type '(choice (const default)
- (const prompt-default)
- (const prompt-exist)
+ (const search-prompt)
+ (const prompt)
(const error))
:safe #'symbolp)
@@ -57,26 +59,25 @@
:safe #'booleanp)
(defcustom ada-build-check-cmd
- (concat "${cross_prefix}gnatmake -u -c -gnatc ${gnatmake_opt}
${full_current} -cargs -I${src_dir} ${comp_opt}")
+ "${cross_prefix}gprbuild -P${gpr_file} -u -c -gnatc ${gprbuild_opt}
${full_current}"
"Default command to syntax check a single file.
Overridden by project variable `check_cmd'."
:type 'string)
(defcustom ada-build-make-cmd
- (concat "${cross_prefix}gnatmake -P${gpr_file} -o ${main} ${main}
${gnatmake_opt} "
- "-cargs -I${src_dir} ${comp_opt} -bargs ${bind_opt} -largs
${link_opt}")
+ "${cross_prefix}gprbuild -P${gpr_file} ${main} ${gprbuild_opt} "
"Default command and link to compile the application.
Overridden by project variable `make_cmd'."
:type 'string)
-(defcustom ada-build-run-cmd "./${main}"
+(defcustom ada-build-run-cmd "${main}"
"Default command to run the application, in a spawned shell.
Overridden by project variable `run_cmd'."
:type 'string)
;;;; code
-(defun ada-build-replace-vars (cmd-string)
+(defun ada-build-replace-vars (project cmd-string)
"Recursively expand variable references in CMD-STRING.
${var} is a project variable or environment variable, $var an
environment variable.
@@ -95,11 +96,26 @@ buffer file name including the directory and extension."
(name (match-string 2 cmd-string))
value)
- (when (string= name "full_current")
+ (cond
+ ((string= name "full_current")
(setq value (buffer-file-name)))
+ ;; Handle names that are likely to occur in commands.
+ ((string= name "src_dir")
+ (setq value (ada-prj-source-path project)))
+
+ ((or (string= name "gpr_project_path")
+ (string= name "ada_project_path"))
+ (setq value (gnat-compiler-project-path (ada-prj-compiler project))))
+
+ ((string= name "gpr_file")
+ (when (gnat-compiler-gpr-file (ada-prj-compiler project))
+ (setq value (file-name-nondirectory (gnat-compiler-gpr-file
(ada-prj-compiler project))))))
+
+ )
+
(when (null value)
- (setq value (ada-prj-get (intern name))))
+ (setq value (plist-get (ada-prj-plist project) (intern name))))
(when (null value)
(setq value (getenv name)))
@@ -120,64 +136,48 @@ buffer file name including the directory and extension."
(substitute-in-file-name cmd-string))
(defun ada-build-default-prj (project)
- "Add to PROJECT the default properties list for Ada project variables used
by ada-build."
- (append
- project
- (list
- 'check_cmd ada-build-check-cmd
- 'main (when (buffer-file-name)
- (file-name-nondirectory
- (file-name-sans-extension (buffer-file-name))))
- 'make_cmd ada-build-make-cmd
- 'run_cmd ada-build-run-cmd
- )))
-
-(defun ada-build-select-default-prj ()
- "Create and select a new default project."
- (let ((prj-file (expand-file-name "default.adp"))
- project)
-
- (when (null (assoc prj-file ada-prj-alist))
- (setq project (ada-prj-default)) ;; ada-build-default-prj included via
ada-prj-default-compiler-alist
-
- (add-to-list 'ada-prj-alist (cons prj-file project))
- )
-
- (ada-select-prj-file prj-file)
- ))
-
-(defun ada-build-find-select-prj-file ()
+ "Add to PROJECT the default project variables used by ada-build."
+ (setf (ada-prj-plist project)
+ (append
+ (ada-prj-plist project)
+ (list
+ 'check_cmd ada-build-check-cmd
+ 'main (when (buffer-file-name)
+ (file-name-nondirectory
+ (file-name-sans-extension (buffer-file-name))))
+ 'make_cmd ada-build-make-cmd
+ 'run_cmd ada-build-run-cmd
+ ))))
+
+(defun ada-build-find-select-prj-file (prj)
"Search for a project file in the current directory, parse and select it.
The file must have the same basename as the project variable
-`main' or the current buffer if `main' is nil, and extension from
-`ada-prj-file-extensions'. Returns non-nil if a file is
+`main' in PRJ or the current buffer if `main' is nil, and extension from
+`wisi-prj-file-extensions'. Returns the project if a file is
selected, nil otherwise."
(let* ((base-file-name (file-name-base
- (or (ada-prj-get 'main)
+ (or (and (ada-prj-p prj)
+ (plist-get (ada-prj-plist prj) 'main))
(file-name-nondirectory (file-name-sans-extension
(buffer-file-name))))))
(filename
- (or
- (file-name-completion base-file-name
- ""
- (lambda (name) (member (file-name-extension
name) ada-prj-file-extensions)))
-
- (file-name-completion base-file-name
- ""
- (lambda (name) (member (file-name-extension
name) ada-prj-file-ext-extra)))))
- )
+ (file-name-completion base-file-name
+ ""
+ (lambda (name) (member (file-name-extension
name) wisi-prj-file-extensions))))
+ )
(when filename
- (ada-parse-prj-file filename)
- (ada-select-prj-file filename))
+ (let ((default-prj (ada-prj-default (file-name-nondirectory
(file-name-sans-extension filename)))))
+ (wisi-prj-dtrt-parse-file filename default-prj filename
default-directory)
+ default-prj))
))
+;;;###autoload
(defun ada-build-prompt-select-prj-file ()
- "Search for a project file, parse and select it.
-The file must have an extension from `ada-prj-file-extensions'.
-Returns non-nil if a file is selected, nil otherwise."
+ "Prompt for a project file, parse and select it.
+The file must have an extension from `wisi-prj-file-extensions'.
+Returns the project if a file is selected, nil otherwise."
(interactive)
- (let ((ext (append ada-prj-file-extensions ada-prj-file-ext-extra))
- filename)
- (condition-case nil
+ (let (filename)
+ (condition-case-unless-debug nil
(setq filename
(read-file-name
"Project file: " ; prompt
@@ -190,19 +190,38 @@ Returns non-nil if a file is selected, nil otherwise."
;; to the desired file. We just assume the user won't
;; return a directory.
(or (file-accessible-directory-p name)
- (member (file-name-extension name) ext)))))
+ (member (file-name-extension name)
wisi-prj-file-extensions)))))
(error
(setq filename nil))
)
- (when (not (equal "" filename))
- (ada-parse-prj-file filename)
- (ada-select-prj-file filename)
- t)
- ))
+ (when (and filename
+ (not (equal "" filename)))
+
+ (unless (wisi-prj-find-function-set-p)
+ ;; See comment in ada-build-require-project-file. We also do
+ ;; this here because it may be the first project-related
+ ;; function the user runs.
+ (add-hook 'project-find-functions #'wisi-prj-find-dominating-cached)
+ (add-hook 'xref-backend-functions #'wisi-prj-xref-backend))
+
+ (let ((default-prj (ada-prj-default (file-name-nondirectory
(file-name-sans-extension filename)))))
+ (wisi-prj-dtrt-parse-file filename default-prj filename
(file-name-directory filename)))
+ )))
+
+(defun ada-build-create-select-default-prj ()
+ "Create a default project with source-path set current directory, select it."
+ (let* ((prj-file (expand-file-name "default_.adp" default-directory)) ;; we
assume this does not exist
+ (ada-xref-tool 'gnat) ;; since we are not specifying a gpr file.
+ (project (ada-prj-default default-directory)))
+
+ ;; We use buffer-file-name as the dominating file (nominally the
+ ;; main program), since we assume it exists but the dummy project
+ ;; file does not.
+ (wisi-prj-dtrt-parse-file prj-file project (file-name-nondirectory
(buffer-file-name)) default-directory)))
(defun ada-build-require-project-file ()
- "Ensure that a project file is selected.
+ "Ensure that a project file is selected, return the project.
Action when no project file is currently selected is determined
by `ada-build-prompt-prj':
@@ -211,31 +230,49 @@ the same name as the main file. If not found, use a
default
project; no gpr file, current directory only, current file as
main.
-default-prompt - Search for a project file in the current
+search-prompt - Search for a project file in the current
directory with the same name as the main file. If not found,
-prompt for a project file; error result does not change current
-project.
+prompt for a project file; thow error if user aborts
-prompt - Prompt for a project file; error result does not
-change current project.
+prompt - Prompt for a project file; thow error if user aborts.
-error - Throw an error (no prompt, no default project)."
- (unless ada-prj-current-file
- (cl-ecase ada-build-prompt-prj
- (default
- (or (ada-build-find-select-prj-file)
- (ada-build-select-default-prj)))
+error - Throw an error (no prompt, no default project).
- (default-prompt
- (or (ada-build-find-select-prj-file)
- (ada-build-prompt-select-prj-file)))
+'search' means look for a file with an extension in
+`wisi-prj-file-extensions'.
- (prompt
- (ada-build-prompt-select-prj-file))
+An error result does not change the current project."
+ (let ((prj (project-current)))
- (error
- (error "no project file selected"))
- )))
+ (unless (wisi-prj-find-function-set-p)
+ ;; We set project-find-functions, xref-backend-functions here so
+ ;; the user doesn't have to for simple projects. We use
+ ;; 'dominating' to avoid the user actions required by select
+ ;; when switching directories/projects (especially in the
+ ;; ada-mode tutorial), and 'cached' to preserve the value of
+ ;; "main" in the project. An experienced user can change to
+ ;; select/cached as they need to.
+ (add-hook 'project-find-functions #'wisi-prj-find-dominating-cached)
+ (add-hook 'xref-backend-functions #'wisi-prj-xref-backend))
+
+ (unless (ada-prj-p prj)
+ (cl-ecase ada-build-prompt-prj
+ (default
+ (or (setq prj (ada-build-find-select-prj-file prj))
+ (setq prj (ada-build-create-select-default-prj))
+ ))
+
+ (search-prompt
+ (or (setq prj (ada-build-find-select-prj-file prj))
+ (setq prj (ada-build-prompt-select-prj-file))))
+
+ (prompt
+ (setq prj (ada-build-prompt-select-prj-file)))
+
+ (error
+ (user-error "no project file selected"))
+ ))
+ prj))
;;;; user functions
@@ -243,9 +280,12 @@ error - Throw an error (no prompt, no default project)."
"Run the command in the PRJ-FIELD project variable.
If CONFIRM or `ada-build-confirm-command' are non-nil, ask for
user confirmation of the command, using PROMPT."
- (ada-build-require-project-file)
- (let ((cmd (ada-prj-get prj-field))
- (process-environment (cl-copy-list (ada-prj-get 'proc_env))))
+ (let* ((project (ada-build-require-project-file))
+ (cmd (plist-get (ada-prj-plist project) prj-field))
+ (compilation-environment
+ (append
+ (wisi-prj-compile-env project)
+ (wisi-prj-file-env project))))
(unless cmd
(setq cmd '("")
@@ -254,7 +294,7 @@ user confirmation of the command, using PROMPT."
(when (or ada-build-confirm-command confirm)
(setq cmd (read-from-minibuffer (concat prompt ": ") cmd)))
- (compile (ada-build-replace-vars cmd))))
+ (compile (ada-build-replace-vars project cmd))))
;;;###autoload
(defun ada-build-check (&optional confirm)
@@ -278,7 +318,10 @@ If CONFIRM is non-nil, prompt for user confirmation of the
command."
By default, this compiles and links the new main program.
If CONFIRM is non-nil, prompt for user confirmation of the command."
(interactive "P")
- (ada-prj-put 'main (file-name-nondirectory (file-name-sans-extension
(buffer-file-name))))
+ (let ((prj (ada-build-require-project-file)))
+ (setf (ada-prj-plist prj)
+ (plist-put (ada-prj-plist prj)
+ 'main (file-name-nondirectory (file-name-sans-extension
(buffer-file-name))))))
(ada-build-run-cmd 'make_cmd confirm "make command"))
;;;###autoload
@@ -292,7 +335,7 @@ If CONFIRM is non-nil, prompt for user confirmation of the
command."
(defun ada-build-show-main ()
"Show current project main program filename."
(interactive)
- (message "Ada mode main: %s"(ada-prj-get 'main)))
+ (message "Ada mode main: %s" (plist-get (ada-prj-plist
(ada-prj-require-prj)) 'main)))
;;; setup
(add-to-list 'ada-prj-default-list 'ada-build-default-prj)
diff --git a/packages/ada-mode/ada-gnat-compile.el
b/packages/ada-mode/ada-compiler-gnat.el
similarity index 77%
rename from packages/ada-mode/ada-gnat-compile.el
rename to packages/ada-mode/ada-compiler-gnat.el
index eb895c3..5663f51 100644
--- a/packages/ada-mode/ada-gnat-compile.el
+++ b/packages/ada-mode/ada-compiler-gnat.el
@@ -1,12 +1,8 @@
-;; ada-gnat-compile.el --- Ada mode compiling functionality provided by 'gnat'
-*- lexical-binding:t -*-
-;; Includes related functions, such as gnatprep support.
-;;
-;; These tools are all Ada-specific; use Makefiles for multi-language
-;; GNAT compilation tools.
-;;
+;;; ada-compiler-gnat.el --- Ada mode compiling functionality provided by GNAT
-*- lexical-binding:t -*-
+;;;
;; GNAT is provided by AdaCore; see http://libre.adacore.com/
;;
-;;; Copyright (C) 2012 - 2019 Free Software Foundation, Inc.
+;;; Copyright (C) 2012 - 2020 Free Software Foundation, Inc.
;;
;; Author: Stephen Leake <address@hidden>
;; Maintainer: Stephen Leake <address@hidden>
@@ -32,17 +28,46 @@
;; file, based on the file extension.
;;
;; By default, ada-mode is configured to load this file, so nothing
-;; special needs to done to use it.
+;; special needs to be done to use it.
+(require 'ada-core)
(require 'cl-lib)
(require 'compile)
(require 'gnat-core)
-(require 'ada-fix-error)
-
-;;;;; code
+(require 'wisi)
;;;; compiler message handling
+(defconst ada-gnat-predefined-package-alist
+ '(
+ ("a-calend" . "Ada.Calendar")
+ ("a-chahan" . "Ada.Characters.Handling")
+ ("a-comlin" . "Ada.Command_Line")
+ ("a-contai" . "Ada.Containers")
+ ("a-direct" . "Ada.Directories")
+ ("a-except" . "Ada.Exceptions")
+ ("a-ioexce" . "Ada.IO_Exceptions")
+ ("a-finali" . "Ada.Finalization")
+ ("a-numeri" . "Ada.Numerics")
+ ("a-nuflra" . "Ada.Numerics.Float_Random")
+ ("a-stream" . "Ada.Streams")
+ ("a-ststio" . "Ada.Streams.Stream_IO")
+ ("a-string" . "Ada.Strings")
+ ("a-strfix" . "Ada.Strings.Fixed")
+ ("a-strmap" . "Ada.Strings.Maps")
+ ("a-strunb" . "Ada.Strings.Unbounded")
+ ("a-stwiun" . "Ada.Strings.Wide_Unbounded")
+ ("a-textio" . "Ada.Text_IO")
+ ("g-comlin" . "GNAT.Command_Line")
+ ("g-dirope" . "GNAT.Directory_Operations")
+ ("g-socket" . "GNAT.Sockets")
+ ("i-c" . "Interfaces.C")
+ ("i-cstrin" . "Interfaces.C.Strings")
+ ("interfac" . "Interfaces")
+ ("s-stoele" . "System.Storage_Elements")
+ )
+ "Alist (filename . package name) of GNAT file names for predefined Ada
packages.")
+
(defun ada-gnat-compilation-filter ()
"Filter to add text properties to secondary file references.
For `compilation-filter-hook'."
@@ -137,9 +162,6 @@ For `compilation-filter-hook'."
"\"\\([,:;=()|]+\\)\""
"regexp to extract quoted punctuation in error messages")
-(defvar ada-gnat-fix-error-hook nil
- "For `ada-fix-error-alist'.")
-
(defun ada-gnat-misspelling ()
"Return correct spelling from current compiler error, if there are
corrections offered.
Prompt user if more than one."
@@ -150,12 +172,14 @@ Prompt user if more than one."
;;
;; column number can vary, so only check the line number
(save-excursion
- (let ((line (progn (beginning-of-line) (nth 1 (compilation--message->loc
(ada-get-compilation-message)))))
- done choices)
+ (let* ((start-msg (get-text-property (line-beginning-position)
'compilation-message))
+ (start-line (nth 1 (compilation--message->loc start-msg)))
+ done choices)
(while (not done)
(forward-line 1)
- (setq done (or (not (ada-get-compilation-message))
- (not (equal line (nth 1 (compilation--message->loc
(ada-get-compilation-message)))))))
+ (let ((msg (get-text-property (line-beginning-position)
'compilation-message)))
+ (setq done (or (not msg)
+ (not (equal start-line (nth 1
(compilation--message->loc msg)))))))
(when (and (not done)
(progn
(skip-syntax-forward "^-")
@@ -184,8 +208,7 @@ Prompt user if more than one."
(match-string 1)
))
-(defun ada-gnat-fix-error (_msg source-buffer _source-window)
- "For `ada-gnat-fix-error-hook'."
+(cl-defmethod wisi-compiler-fix-error ((_compiler gnat-compiler) source-buffer)
(let ((start-pos (point))
message-column
result)
@@ -222,9 +245,10 @@ Prompt user if more than one."
t))
((looking-at (concat ada-gnat-quoted-name-regexp " is not visible"))
- (let ((done nil)
- (file-line-struct (progn (beginning-of-line)
(ada-get-compilation-message)))
- pos choices unit-name)
+ (let* ((done nil)
+ (err-msg (get-text-property (line-beginning-position)
'compilation-message))
+ (file-line-struct err-msg)
+ pos choices unit-name)
;; next line may contain a reference to where ident is
;; defined; if present, it will have been marked by
;; ada-gnat-compilation-filter:
@@ -247,13 +271,14 @@ Prompt user if more than one."
;; 1- because next compilation error is at next line beginning
(setq done (not
(and
- (equal file-line-struct
(ada-get-compilation-message))
+ (equal file-line-struct err-msg)
(setq pos (next-single-property-change (point)
'ada-secondary-error nil limit))
(< pos limit))))
(when (not done)
(let* ((item (get-text-property pos 'ada-secondary-error))
(unit-file (nth 0 item))
- (choice (ada-ada-name-from-file-name unit-file)))
+ (prj (project-current))
+ (choice (ada-compiler-ada-name-from-file-name
(wisi-prj-compiler prj) prj unit-file)))
(unless (member choice choices) (push choice choices))
(goto-char (1+ pos))
(goto-char (1+ (next-single-property-change (point)
'ada-secondary-error nil limit)))
@@ -461,9 +486,12 @@ Prompt user if more than one."
((looking-at (concat "operator for \\(private \\)?type "
ada-gnat-quoted-name-regexp
"\\( defined at " ada-gnat-file-name-regexp
"\\)?"))
(let ((type (match-string 2))
- (package-file (match-string 4)))
+ (package-file (match-string 4))
+ (prj (project-current)))
(when package-file
- (setq type (concat (ada-gnat-ada-name-from-file-name
package-file) "." type)))
+ (setq type (concat
+ (ada-compiler-ada-name-from-file-name
(wisi-prj-compiler prj) prj package-file)
+ "." type)))
(pop-to-buffer source-buffer)
(ada-fix-add-use-type type)
t))
@@ -560,7 +588,7 @@ Prompt user if more than one."
((looking-at (concat "warning: variable " ada-gnat-quoted-name-regexp
" is assigned but never read"))
(let ((param (match-string 1)))
(pop-to-buffer source-buffer)
- (ada-goto-end) ;; leaves point before semicolon
+ (wisi-goto-statement-end) ;; leaves point before semicolon
(forward-char 1)
(newline-and-indent)
(insert "pragma Unreferenced (" param ");"))
@@ -590,7 +618,7 @@ Prompt user if more than one."
((looking-at "(style) bad capitalization, mixed case required")
(set-buffer source-buffer)
(forward-word)
- (ada-case-adjust-identifier)
+ (wisi-case-adjust-identifier)
t)
((looking-at (concat "(style) bad casing of "
ada-gnat-quoted-name-regexp))
@@ -658,108 +686,110 @@ Prompt user if more than one."
nil)
))
-;;;;; setup
-
-(defun ada-gnat-compile-select-prj ()
- (add-to-list 'ada-fix-error-hook #'ada-gnat-fix-error)
- (setq ada-prj-show-prj-path 'gnat-prj-show-prj-path)
- (add-to-list 'completion-ignored-extensions ".ali") ;; gnat library files
- (add-hook 'ada-syntax-propertize-hook 'ada-gnat-syntax-propertize)
- (add-hook 'ada-syntax-propertize-hook 'gnatprep-syntax-propertize)
- (syntax-ppss-flush-cache (point-min));; force re-evaluate with hook.
-
- ;; There is no common convention for a file extension for gnatprep files.
- ;;
- ;; find error locations in .gpr files
- (setq compilation-search-path (append compilation-search-path (ada-prj-get
'prj_dir)))
-
- ;; ‘compilation-environment’ is buffer-local, but the user might
- ;; delete that buffer. So set both global and local.
- (let* ((process-environment (ada-prj-get 'proc_env))
- (gpr-path (getenv "GPR_PROJECT_PATH"))
- (comp-env (list (concat "GPR_PROJECT_PATH=" gpr-path)))
- (comp-buf (get-buffer "*compilation*")))
- (when (buffer-live-p comp-buf)
- (with-current-buffer comp-buf
- (setq compilation-environment comp-env)))
- (set-default 'compilation-environment comp-env)
- )
-
- (when (getenv "GPR_PROJECT_PATH")
- ;; We get here when this is called from
- ;; ‘compilation-process-setup-function’; ‘process-environment’ is
- ;; already bound to ‘compilation-environment’. Or when the user
- ;; has set GPR_PROJECT_PATH in top level ‘process-environment’,
- ;; which is a mistake on their part.
- (setenv "GPR_PROJECT_PATH"
- (mapconcat 'identity
- (ada-prj-get 'prj_dir)
- (ada-prj-get 'path_sep))))
-
- ;; must be after indentation engine setup, because that resets the
- ;; indent function list.
- (add-hook 'ada-mode-hook 'gnatprep-setup t)
+;;;; generic methods
+(cl-defmethod ada-prj-select-compiler ((_compiler gnat-compiler) _project)
+ ;; These can't be in wisi-compiler-select-prj (gnat-compiler),
+ ;; because that is shared with gpr-mode (and maybe others).
(add-hook 'compilation-filter-hook 'ada-gnat-compilation-filter)
+ (add-hook 'ada-syntax-propertize-hook #'ada-gnat-syntax-propertize)
- ;; ada-mode.el project file parser sets this to other compilers used
- ;; in the project, so we only add here.
- (add-to-list 'compilation-error-regexp-alist 'gnat)
+ ;; We should call `syntax-ppss-flush-cache' here, to force ppss with
+ ;; the new hook function. But that must be done in all ada-mode
+ ;; buffers, which is tedious. So we're ignoring it until it becomes
+ ;; a problem; normally, the compiler is selected before any Ada
+ ;; files are visited, so it's not an issue.
)
-(defun ada-gnat-compile-deselect-prj ()
- (setq ada-fix-error-hook (delete #'ada-gnat-fix-error ada-fix-error-hook))
- (setq completion-ignored-extensions (delete ".ali"
completion-ignored-extensions))
- (setq ada-syntax-propertize-hook (delq 'gnatprep-syntax-propertize
ada-syntax-propertize-hook))
- (setq ada-syntax-propertize-hook (delq 'ada-gnat-syntax-propertize
ada-syntax-propertize-hook))
- (syntax-ppss-flush-cache (point-min));; force re-evaluate with hook.
+(cl-defmethod ada-prj-deselect-compiler ((_compiler gnat-compiler) _project)
+ (remove-hook 'ada-syntax-propertize-hook #'ada-gnat-syntax-propertize)
+ (remove-hook 'compilation-filter-hook #'ada-gnat-compilation-filter)
+ )
- ;; Don't need to delete from compilation-search-path; completely
- ;; rewritten in ada-gnat-compile-select-prj.
- (setq compilation-environment nil)
+(cl-defmethod ada-compiler-file-name-from-ada-name ((compiler gnat-compiler)
project ada-name)
+ (let ((result nil))
- (setq ada-mode-hook (delq 'gnatprep-setup ada-mode-hook))
+ (while (string-match "\\." ada-name)
+ (setq ada-name (replace-match "-" t t ada-name)))
- (setq compilation-filter-hook (delete 'ada-gnat-compilation-filter
compilation-filter-hook))
- (setq compilation-error-regexp-alist (delete 'gnat
compilation-error-regexp-alist))
- )
+ (setq ada-name (downcase ada-name))
-(defun ada-gnat-compile ()
- "Set Ada mode global vars to use `gnat' for compiling."
- (add-to-list 'ada-prj-file-ext-extra "gpr")
- (add-to-list 'ada-prj-parser-alist '("gpr" . gnat-parse-gpr))
- (add-to-list 'ada-select-prj-compiler '(gnat .
ada-gnat-compile-select-prj))
- (add-to-list 'ada-deselect-prj-compiler '(gnat .
ada-gnat-compile-deselect-prj))
-
- (add-to-list 'ada-prj-parse-one-compiler (cons 'gnat
'gnat-prj-parse-emacs-one))
- (add-to-list 'ada-prj-parse-final-compiler (cons 'gnat
'gnat-prj-parse-emacs-final))
-
- (font-lock-add-keywords 'ada-mode
- ;; gnatprep preprocessor line
- (list (list "^[ \t]*\\(#.*\n\\)" '(1 font-lock-preprocessor-face t)))))
-
-(provide 'ada-gnat-compile)
-(provide 'ada-compiler)
-
-(ada-gnat-compile)
-
-(add-to-list
- 'compilation-error-regexp-alist-alist
- '(gnat
- ;; typical:
- ;; cards_package.adb:45:32: expected private type "System.Address"
- ;;
- ;; with full path Source_Reference pragma :
- ;; d:/maphds/version_x/1773/sbs-abi-dll_lib.ads.gp:39:06: file
"interfaces_c.ads" not found
- ;;
- ;; gnu cc1: (gnatmake can invoke the C compiler)
- ;; foo.c:2: `TRUE' undeclared here (not in a function)
- ;; foo.c:2 : `TRUE' undeclared here (not in a function)
- ;;
- ;; we can't handle secondary errors here, because a regexp can't
distinquish "message" from "filename"
- "^\\(\\(.:\\)?[^ :\n]+\\):\\([0-9]+\\)\\s-?:?\\([0-9]+\\)?" 1 3 4))
-
-(unless (default-value 'ada-compiler)
- (set-default 'ada-compiler 'gnat))
-
-;; end of file
+ (with-current-buffer (gnat-run-buffer project
(gnat-compiler-run-buffer-name compiler))
+ (gnat-run-no-prj
+ (list
+ "krunch"
+ ada-name
+ ;; "0" means only krunch GNAT library names
+ "0"))
+
+ (goto-char (point-min))
+ (when ada-gnat-debug-run (forward-line 1)); skip cmd
+ (setq result (buffer-substring-no-properties (line-beginning-position)
(line-end-position)))
+ )
+ result))
+
+(cl-defmethod ada-compiler-ada-name-from-file-name ((_compiler gnat-compiler)
_project file-name)
+ (let* ((ada-name (file-name-sans-extension (file-name-nondirectory
file-name)))
+ (predefined (cdr (assoc ada-name ada-gnat-predefined-package-alist))))
+
+ (if predefined
+ predefined
+ (while (string-match "-" ada-name)
+ (setq ada-name (replace-match "." t t ada-name)))
+ ada-name)))
+
+(cl-defmethod ada-compiler-make-package-body ((compiler gnat-compiler) project
body-file-name)
+ ;; gnatstub always creates the body in the current directory (in the
+ ;; process where gnatstub is running); the -o parameter may not
+ ;; contain path info. So we bind default-directory here.
+ (let ((start-file (buffer-file-name))
+ (opts (when (gnat-compiler-gnat-stub-opts compiler)
+ (split-string (gnat-compiler-gnat-stub-opts compiler))))
+ (cargs (when (gnat-compiler-gnat-stub-cargs compiler)
+ (append (list "-cargs") (split-string
(gnat-compiler-gnat-stub-cargs compiler)))))
+ (process-environment
+ (append
+ (wisi-prj-compile-env project)
+ (wisi-prj-file-env project)
+ (copy-sequence process-environment)))
+ )
+
+ ;; Make sure all relevant files are saved to disk.
+ (save-some-buffers t)
+
+ (with-current-buffer (gnat-run-buffer compiler
(gnat-compiler-run-buffer-name compiler))
+ (let ((default-directory (file-name-directory body-file-name)))
+ (gnat-run-gnat
+ project
+ "stub"
+ (append opts (list start-file) cargs))
+
+ (find-file body-file-name)
+ (indent-region (point-min) (point-max))
+ (save-buffer)))
+ nil))
+
+(defun ada-gnat-syntax-propertize (start end)
+ (goto-char start)
+ (save-match-data
+ (while (re-search-forward
+ (concat
+ "[^a-zA-Z0-9)]\\('\\)\\[[\"a-fA-F0-9]+\"\\]\\('\\)"; 1, 2:
non-ascii character literal, not attributes
+ "\\|\\(\\[\"[a-fA-F0-9]+\"\\]\\)"; 3: non-ascii character in
identifier
+ )
+ end t)
+ (cond
+ ((match-beginning 1)
+ (put-text-property
+ (match-beginning 1) (match-end 1) 'syntax-table '(7 . ?'))
+ (put-text-property
+ (match-beginning 2) (match-end 2) 'syntax-table '(7 . ?')))
+
+ ((match-beginning 3)
+ (put-text-property
+ (match-beginning 3) (match-end 3) 'syntax-table '(2 . nil)))
+ )
+ )))
+
+(provide 'ada-compiler-gnat)
+;; ada-compiler-gnat.el ends here
diff --git a/packages/ada-mode/ada-core.el b/packages/ada-mode/ada-core.el
new file mode 100644
index 0000000..4157664
--- /dev/null
+++ b/packages/ada-mode/ada-core.el
@@ -0,0 +1,762 @@
+;;; ada-core.el --- core facilities for ada-mode -*- lexical-binding:t -*-
+
+;; Copyright (C) 1994, 1995, 1997 - 2017, 2019 - 2020 Free Software
Foundation, Inc.
+;;
+;; Author: Stephen Leake <address@hidden>
+;; Maintainer: Stephen Leake <address@hidden>
+;;
+;; This file is part of GNU Emacs.
+;;
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+;;
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+;;
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
+
+(require 'compile)
+(require 'find-file)
+(require 'uniquify-files)
+(require 'wisi)
+(require 'wisi-prj)
+
+;;;; misc
+
+(defgroup ada nil
+ "Major mode for editing Ada source code in Emacs."
+ :group 'languages)
+
+(defcustom ada-fix-sort-context-clause t
+ "*If non-nil, sort context clause when inserting `with'"
+ :type 'boolean
+ :group 'ada)
+
+(defconst ada-operator-re
+
"\\+\\|-\\|/\\|\\*\\*\\|\\*\\|=\\|&\\|\\_<\\(abs\\|mod\\|rem\\|and\\|not\\|or\\|xor\\)\\_>\\|<=\\|<\\|>=\\|>"
+ "Regexp matching Ada operator_symbol.")
+
+(defconst ada-name-regexp
+ "\\(\\(?:\\sw\\|[_.]\\)+\\)")
+
+(defvar ada-compiler 'gnat
+ "Default Ada compiler; can be overridden in project files.
+Values defined by compiler packages.")
+
+(defvar ada-syntax-propertize-hook nil
+ "Hook run from `ada-syntax-propertize'.
+Called by `syntax-propertize', which is called by font-lock in
+`after-change-functions'.")
+
+(defun ada-declarative-region-start-p (cache)
+ "Return t if cache is a keyword starting a declarative region."
+ (memq (wisi-cache-token cache) '(DECLARE IS PRIVATE))
+ ;; IS has a cache only if start of declarative region
+ )
+
+(defun ada-goto-declarative-region-start ()
+ "Goto start of declarative region containing point."
+ (interactive)
+ (wisi-validate-cache (point-min) (point-max) t 'navigate)
+
+ (let ((done nil)
+ (start-pos (point))
+ (outermost nil)
+ (cache (or (wisi-get-cache (point))
+ (wisi-backward-cache))))
+
+ ;; We use backward-cache, not forward-cache, to handle the case
+ ;; where point is in the whitespace or comment before a block; we
+ ;; want the containing block, not the next block.
+ ;;
+ ;; The typical use case for calling this fuction is to add a
+ ;; use_clause for an identifier/operator at start-pos.
+
+ (when cache ;; nil at bob
+ (while (not done)
+ (unless (wisi-cache-containing cache)
+ (setq outermost t))
+
+ (if (ada-declarative-region-start-p cache)
+ (if (< (point) start-pos)
+ (progn
+ (forward-word);; past 'is'
+ (setq done t))
+
+ ;; test/ada_mode-nominal.adb function F2
+ ;;
+ ;; start-point is in a formal_part or aspect_clause; we
+ ;; want the next level up.
+ (if outermost
+ ;; there is no next level up; add the use_clause in the
context_clause.
+ (progn
+ (setq cache (wisi-goto-containing cache))
+ (setq done t))
+
+ (setq cache (wisi-goto-containing cache))
+ (setq cache (wisi-goto-containing cache))))
+
+ (cl-case (wisi-cache-class cache)
+ (motion
+ (setq cache (wisi-goto-containing cache)));; statement-start
+
+ (statement-end
+ (setq cache (wisi-goto-containing cache)) ;; statement-start
+ (cl-case (wisi-cache-nonterm cache)
+ ((generic_package_declaration
+ package_declaration
+ entry_body package_body package_declaration protected_body
subprogram_body task_body
+ protected_type_declaration single_protected_declaration
single_task_declaration task_type_declaration)
+ ;; This is a block scope before the starting point; we want the
containing scope
+ (setq cache (wisi-goto-containing cache)))
+
+ (t
+ nil)
+ ))
+
+ (statement-start
+ (cl-case (wisi-cache-nonterm cache)
+ (generic_package_declaration
+ (setq cache (wisi-next-statement-cache cache)) ;; 'package'
+ (setq cache (wisi-next-statement-cache cache))) ;; 'is'
+
+ (package_declaration
+ (setq cache (wisi-next-statement-cache cache))) ;; 'is'
+
+ ((entry_body package_body protected_body subprogram_body
task_body)
+ (while (not (eq 'IS (wisi-cache-token cache)))
+ (setq cache (wisi-next-statement-cache cache))))
+
+ ((protected_type_declaration single_protected_declaration
single_task_declaration task_type_declaration)
+ (while (not (eq 'IS (wisi-cache-token cache)))
+ (setq cache (wisi-next-statement-cache cache)))
+ (when (looking-at "\<new\>")
+ (while (not (eq 'WITH (wisi-cache-token cache)))
+ (setq cache (wisi-next-statement-cache cache)))))
+
+ (t
+ (setq cache (wisi-goto-containing cache t)))
+ ))
+
+ (t
+ (setq cache (wisi-goto-containing cache t)))
+ )))
+ )))
+
+;;;; additional ada-compiler generic interfaces
+
+(cl-defgeneric ada-compiler-file-name-from-ada-name (compiler project ada-name)
+ "Return the filename that would contain the library level ADA-NAME.")
+
+(defun ada-file-name-from-ada-name (ada-name)
+ "Return the filename in which ADA-NAME is found."
+ (let ((project (ada-prj-require-prj)))
+ (ada-compiler-file-name-from-ada-name (ada-prj-compiler project) project
ada-name)))
+
+(cl-defgeneric ada-compiler-ada-name-from-file-name (compiler project
file-name)
+ "Return the Ada library unit name that should be found in FILE-NAME.")
+
+(cl-defgeneric ada-compiler-make-package-body (compiler project body-file-name)
+ "Create a package body skeleton from a package spec.
+BODY-FILE-NAME is the file name of the body file. Current buffer
+is the package spec.")
+
+(defun ada-make-package-body (body-file-name)
+ (let ((prj (ada-prj-require-prj)))
+ (ada-compiler-make-package-body (ada-prj-compiler prj)
+ prj
+ (expand-file-name body-file-name))))
+
+;;;; refactor
+
+;; Refactor actions; must match wisi-ada.adb Refactor
+(defconst ada-refactor-method-object-to-object-method 1)
+(defconst ada-refactor-object-method-to-method-object 2)
+
+(defconst ada-refactor-element-object-to-object-index 3)
+(defconst ada-refactor-object-index-to-element-object 4)
+
+(defconst ada-refactor-format-paramlist 5)
+
+(defun ada-refactor (action)
+ (wisi-validate-cache (line-end-position -7) (line-end-position 7) t
'navigate)
+ (save-excursion
+ (skip-syntax-backward "w_.\"")
+ (let* ((edit-begin (point))
+ (cache (wisi-goto-statement-start))
+ (parse-begin (point))
+ (parse-end (wisi-cache-end cache)))
+ (if parse-end
+ (setq parse-end (+ parse-end (wisi-cache-last (wisi-get-cache
(wisi-cache-end cache)))))
+ ;; else there is a syntax error; missing end of statement
+ (setq parse-end (point-max)))
+ (wisi-refactor wisi--parser action parse-begin parse-end edit-begin)
+ )))
+
+(defun ada-refactor-1 ()
+ "Refactor Method (Object) => Object.Method.
+Point must be in Method."
+ (interactive)
+ (ada-refactor ada-refactor-method-object-to-object-method))
+
+(defun ada-refactor-2 ()
+ "Refactor Object.Method => Method (Object).
+Point must be in Object.Method."
+ (interactive)
+ (ada-refactor ada-refactor-object-method-to-method-object))
+
+(defun ada-refactor-3 ()
+ "Refactor Element (Object, Index) => Object (Index).
+Point must be in Element"
+ (interactive)
+ (ada-refactor ada-refactor-element-object-to-object-index))
+
+(defun ada-refactor-4 ()
+ "Refactor Object (Index) => Element (Object, Index).
+Point must be in Object"
+ (interactive)
+ (ada-refactor ada-refactor-object-index-to-element-object))
+
+;; refactor-5 in ada-format-paramlist below
+
+(defcustom ada-language-version 'ada2012
+ ;; ada-fix-error.el needs this.
+ "Ada language version; one of `ada83', `ada95', `ada2005', `ada2012'.
+Only affects the keywords to highlight, not which version the
+parser accepts; the parser always accepts a superset of ada2012."
+ :type '(choice (const ada83)
+ (const ada95)
+ (const ada2005)
+ (const ada2012))
+ :safe #'symbolp)
+(make-variable-buffer-local 'ada-language-version)
+
+(defun ada-in-case-expression ()
+ "Return non-nil if point is in a case expression."
+ (save-excursion
+ ;; Used by ada-align; we know we are in a paren.
+ (wisi-goto-open-paren 1)
+ (while (forward-comment 1))
+ (looking-at "case")))
+
+(defun ada-align ()
+ "If region is active, apply `align'. If not, attempt to align
+current construct."
+ (interactive)
+ (if (use-region-p)
+ (progn
+ (align (region-beginning) (region-end))
+ (deactivate-mark))
+
+ ;; else see if we are in a construct we know how to align
+ (let ((parse-result (syntax-ppss)))
+ (cond
+ ((ada-in-paramlist-p parse-result)
+ (ada-format-paramlist))
+
+ ((and
+ (wisi-in-paren-p parse-result)
+ (ada-in-case-expression))
+ ;; align '=>'
+ (let* ((begin (nth 1 parse-result))
+ (end (scan-lists begin 1 0)))
+ (align begin end 'entire)))
+
+ (t
+ (align-current))
+ ))))
+
+(defun ada-in-paramlist-p (parse-result)
+ "Return t if point is inside the parameter-list of a subprogram declaration.
+PARSE-RESULT must be the result of `syntax-ppss'."
+ (wisi-validate-cache (point-min) (point-max) nil 'navigate)
+ ;; (info "(elisp)Parser State" "*syntax-ppss*")
+ (let (cache)
+ (and (> (nth 0 parse-result) 0)
+ ;; cache is nil if the parse failed
+ (setq cache (wisi-get-cache (nth 1 parse-result)))
+ (eq 'formal_part (wisi-cache-nonterm cache)))
+ ))
+
+(defun ada-format-paramlist ()
+ "Reformat the parameter list point is in."
+ (interactive)
+ (condition-case nil
+ (wisi-goto-open-paren)
+ (error
+ (user-error "Not in parameter list")))
+ (funcall indent-line-function); so new list is indented properly
+ (when (not (looking-back "^[ \t]*" (line-beginning-position)))
+ (delete-horizontal-space)
+ (insert " "))
+ (ada-refactor ada-refactor-format-paramlist))
+
+;;;; fix compiler errors
+(defun ada-fix-context-clause ()
+ "Return the region containing the context clause for the current buffer,
+excluding leading pragmas."
+ (wisi-validate-cache (point-min) (point-max) t 'navigate)
+ (save-excursion
+ (goto-char (point-min))
+ (let ((begin nil)
+ (end nil)
+ cache)
+
+ (while (not end)
+ (setq cache (wisi-forward-cache))
+ (cl-case (wisi-cache-nonterm cache)
+ (pragma_g (wisi-goto-end-1 cache))
+ (use_clause (wisi-goto-end-1 cache))
+ (with_clause
+ (when (not begin)
+ (setq begin (line-beginning-position)))
+ (wisi-goto-end-1 cache))
+ (t
+ ;; start of compilation unit
+ (setq end (line-beginning-position))
+ (unless begin
+ (setq begin end)))
+ ))
+ (cons begin end)
+ )))
+
+(defun ada-fix-sort-context-pred (a b)
+ "Predicate for `sort-subr'; sorts \"limited with\", \"private with\" last.
+Returns non-nil if a should preceed b in buffer."
+ ;; a, b are buffer ranges in the current buffer
+ (cl-flet
+ ((starts-with
+ (pat reg)
+ (string= pat (buffer-substring-no-properties (car reg)
+ (min (point-max)
+ (+(car reg) (length
pat)))))))
+ (cond
+ ((and
+ (starts-with "limited with" a)
+ (starts-with "private with" b))
+ t)
+
+ ((and
+ (starts-with "limited with" a)
+ (not (starts-with "limited with" b)))
+ nil)
+
+ ((and
+ (not (starts-with "limited with" a))
+ (starts-with "limited with" b))
+ t)
+
+ ((and
+ (starts-with "private with" a)
+ (not (starts-with "private with" b)))
+ nil)
+
+ ((and
+ (not (starts-with "private with" a))
+ (starts-with "private with" b))
+ t)
+
+ (t
+ (> 0 (compare-buffer-substrings
+ nil (car a) (cdr a)
+ nil (car b) (cdr b))) )
+ )))
+
+(defun ada-fix-sort-context-clause (beg end)
+ "Sort context clauses in range BEG END."
+ (save-excursion
+ (save-restriction
+ (narrow-to-region beg end)
+ (goto-char (point-min))
+ (sort-subr nil 'forward-line 'end-of-line nil nil
'ada-fix-sort-context-pred)
+ )))
+
+(defun ada-fix-add-with-clause (package-name)
+ "Add a with_clause for PACKAGE_NAME.
+If ada-fix-sort-context-clause, sort the context clauses using
+sort-lines."
+ (let ((context-clause (ada-fix-context-clause)))
+ (when (not context-clause)
+ (error "no compilation unit found"))
+
+ (goto-char (cdr context-clause))
+ (insert "with ")
+ (ada-fix-insert-unit-name package-name)
+ (insert ";\n")
+
+ (when (and (< (car context-clause) (cdr context-clause))
+ ada-fix-sort-context-clause)
+ (ada-fix-sort-context-clause (car context-clause) (point)))
+ ))
+
+(defun ada-fix-extend-with-clause (child-name)
+ "Assuming point is in a selected name, just before CHILD-NAME, add or
+extend a with_clause to include CHILD-NAME . "
+ (let ((parent-name-end (point)))
+ ;; Find the full parent name; skip back to whitespace, then match
+ ;; the name forward.
+ (skip-syntax-backward "w_.")
+ (search-forward-regexp ada-name-regexp parent-name-end)
+ (let ((parent-name (match-string 0))
+ (context-clause (ada-fix-context-clause)))
+ (goto-char (car context-clause))
+ (if (search-forward-regexp (concat "^with " parent-name ";") (cdr
context-clause) t)
+ ;; found exisiting 'with' for parent; extend it
+ (progn
+ (forward-char -1) ; skip back over semicolon
+ (insert "." child-name))
+
+ ;; not found; we are in a package body, with_clause for parent is in
spec.
+ ;; insert a new one
+ (ada-fix-add-with-clause (concat parent-name "." child-name)))
+ )))
+
+(defun ada-fix-insert-unit-name (unit-name)
+ "Insert UNIT-NAME at point and capitalize it."
+ ;; unit-name is normally gotten from a file-name, and is thus all lower-case.
+ (let ((start-point (point))
+ search-bound)
+ (insert unit-name)
+ (setq search-bound (point))
+ (insert " ") ; separate from following words, if any, for
wisi-case-adjust-identifier
+ (goto-char start-point)
+ (while (search-forward "." search-bound t)
+ (forward-char -1)
+ (wisi-case-adjust-identifier)
+ (forward-char 1))
+ (goto-char search-bound)
+ (wisi-case-adjust-identifier)
+ (delete-char 1)))
+
+(defun ada-fix-add-use-type (type)
+ "Insert `use type' clause for TYPE at start of declarative part for current
construct."
+ (ada-goto-declarative-region-start); leaves point after 'is'
+ (newline-and-indent)
+ (cl-ecase ada-language-version
+ (ada2012
+ (insert "use all type "))
+ ((ada83 ada95 ada2005)
+ (insert "use type ")))
+ (let ((begin (point))
+ end)
+ (insert type ";")
+ (setq end (point))
+ (goto-char begin)
+ (while (< (point) end)
+ (wisi-case-adjust-at-point)
+ (forward-char 1))
+ ))
+
+(defun ada-fix-add-use (package)
+ "Insert `use' clause for PACKAGE at start of declarative part for current
construct."
+ (ada-goto-declarative-region-start); leaves point after 'is'
+ (newline-and-indent)
+ (insert "use " package ";"))
+
+;;;; xref
+
+(defvar ada-xref-tool (if (locate-file "gpr_query" exec-path '("" ".exe"))
'gpr_query 'gnat)
+ "Default Ada cross reference tool; can be overridden in project files.")
+
+(defconst ada-xref-known-tools '(gpr_query gnat)
+ "Supported xref tools")
+
+(defun ada-make-subprogram-body ()
+ "Convert subprogram specification after point into a subprogram body stub."
+ (interactive)
+ (wisi-goto-statement-start)
+ ;; point is at start of subprogram specification;
+ ;; wisi-parse-expand-region will find the terminal semicolon.
+ (wisi-validate-cache (point-min) (point-max) t 'navigate)
+
+ (let* ((begin (point))
+ (end (wisi-cache-end (wisi-get-cache (point))))
+ (name (wisi-next-name)))
+ (goto-char end)
+ (newline)
+ (insert " is begin\n\nend ");; legal syntax; parse does not fail
+ (insert name)
+ (forward-char 1)
+
+ ;; newline after body to separate from next body
+ (newline-and-indent)
+ (indent-region begin (point))
+ (forward-line -2)
+ (back-to-indentation)
+ ))
+
+(defun ada-ff-create-body ()
+ ;; ff-find-other-file calls this with point in an empty buffer for
+ ;; the body file; ada-make-package-body expects to be in the
+ ;; spec. So go back to the spec, and delete the body buffer so it
+ ;; does not get written to disk.
+ (let ((body-buffer (current-buffer))
+ (body-file-name (buffer-file-name))
+ (prj (ada-prj-require-prj)))
+
+ (set-buffer-modified-p nil);; may have a skeleton; allow silent delete
+
+ (ff-find-the-other-file);; back to spec
+
+ (kill-buffer body-buffer)
+
+ (ada-compiler-make-package-body (ada-prj-compiler prj) prj body-file-name)
+
+ ;; back to the new body file, read in from the disk.
+ (ff-find-the-other-file)
+ (revert-buffer t t))
+ )
+
+;;;; project files
+
+(cl-defstruct
+ (ada-prj
+ (:include wisi-prj)
+ (:copier nil)
+ (:constructor nil)
+ (:constructor make-ada-prj
+ (&key
+ name
+ compile-env
+ (compiler-label ada-compiler)
+ (xref-label ada-xref-tool)
+ source-path
+ plist
+ file-pred
+ &aux
+ (compiler (ada-prj-make-compiler compiler-label))
+ (xref (ada-prj-make-xref xref-label))
+ (compile-env (ada-prj-check-env compile-env))
+ )))
+ compiler-label
+ xref-label
+ ;; save labels for wisi-prj-default
+
+ plist ;; user-declared project variables; also obj_dir, mostly as an
example.
+ )
+
+;;;###autoload
+(cl-defun create-ada-prj
+ (&key
+ name
+ compile-env
+ (compiler-label ada-compiler)
+ (xref-label ada-xref-tool)
+ source-path
+ plist
+ file-pred)
+ ;; We declare and autoload this because we can't autoload
+ ;; make-ada-prj in emacs < 27. We can't use '(defalias
+ ;; 'create-ada-prj 'make-ada-prj); then make-ada-prj is not defined
+ ;; by autoload.
+ (make-ada-prj
+ :name name
+ :compile-env compile-env
+ :compiler-label compiler-label
+ :xref-label xref-label
+ :source-path source-path
+ :plist plist
+ :file-pred file-pred))
+
+(defun ada-prj-check-env (env)
+ "Check that ENV has the proper structure; list of \"NAME=VALUE\".
+Return ENV."
+ ;; Previous versions used ("NAME" . "VALUE"), which screws up.
+ (let ((err-msg "env is not list of \"NAME=VALUE\"."))
+ (unless (listp env)
+ (error err-msg))
+ (dolist (item env)
+ (unless (stringp item)
+ (error err-msg))))
+ env)
+
+(defvar ada-prj-default-list nil
+ ;; This is used by ada-build.el; we keep it to allow other similar
+ ;; uses.
+ "List of functions to add default project variables. Called
+with one argument; the project. `default-directory' is set to the
+directory containing the project file. Function should update the
+project.")
+
+;;;###autoload
+(defun ada-prj-default (&optional name src-dir)
+ "Return the default `ada-prj' object.
+If SRC-DIR is non-nil, use it as the default for project.source-path."
+ (let ((project
+ (make-ada-prj
+ :name (or name "_default_")
+ :compiler-label ada-compiler
+ :xref-label ada-xref-tool
+ :source-path (cond
+ ((null src-dir) nil)
+ ((listp src-dir) src-dir)
+ (t (list src-dir)))
+ )))
+
+ (cl-dolist (func ada-prj-default-list)
+ (funcall func project))
+
+ project))
+
+(cl-defmethod wisi-prj-default ((prj ada-prj))
+ (let ((project
+ (make-ada-prj
+ :name (wisi-prj-name prj)
+ :compile-env (wisi-prj-compile-env prj)
+ :compiler-label (ada-prj-compiler-label prj)
+ :xref-label (ada-prj-xref-label prj)
+ )))
+
+ (cl-dolist (func ada-prj-default-list)
+ (funcall func project))
+
+ project))
+
+;;;###autoload
+(defun ada-prj-make-compiler (label)
+ ;; We use the autoloaded constructor here
+ (require (intern (format "ada-compiler-%s" (symbol-name label))))
+ (funcall (intern (format "create-%s-compiler" (symbol-name label)))))
+
+(defun ada-prj-make-xref (label)
+ ;; We use the autoloaded constructor here
+ (funcall (intern (format "create-%s-xref" (symbol-name label))))
+ ;; So far the only ada xref we have is gpr_query, which uses a
+ ;; gnat-compiler object, so no new require here.
+ )
+
+(defun ada-prj-require-prj ()
+ "Return current `ada-prj' object.
+Throw an error if current project is not an ada-prj."
+ (let ((prj (project-current)))
+ (if (ada-prj-p prj)
+ prj
+ (error "current project is not an ada project."))))
+
+(cl-defmethod wisi-prj-parse-one :after (project name value)
+ (cond
+ ;; variable name alphabetical order
+ ((string= name "ada_compiler")
+ (let ((comp (intern value)))
+ (setf (ada-prj-compiler project) (ada-prj-make-compiler comp))))
+
+ ((string= name "obj_dir")
+ (let ((obj-dir (plist-get (ada-prj-plist project) 'obj_dir)))
+ (cl-pushnew (file-name-as-directory (expand-file-name value))
+ obj-dir :test #'equal)
+ (setf (ada-prj-plist project) (plist-put (ada-prj-plist project)
'obj_dir obj-dir))
+ ))
+
+ ((string= name "xref_tool")
+ ;; This is defined here, rather than in wisi, because the list of
+ ;; xref tools is likely to be language-specific (but not always;
+ ;; for example Gnu global supports many languages).
+ (let ((xref-label (intern value)))
+ (if (memq xref-label ada-xref-known-tools)
+ (progn
+ (setf (ada-prj-xref-label project) xref-label)
+ (setf (ada-prj-xref project) (ada-prj-make-xref xref-label)))
+
+ (user-error "'%s' is not a recognized xref tool (must be one of %s)"
+ xref-label ada-xref-known-tools))
+ ))
+ ))
+
+(defun ada-prj-parse-undefined (project name value)
+ "For `wisi-prj-parse-undefined-function'."
+ ;; Otherwise undefined names are set as a project file variable.
+ ;; eg "comp_opt"
+ ;;
+ ;; This is defined here, rather than in wisi, because we only
+ ;; maintain it for compatibility with previous ada-mode versions.
+ ;;
+ ;; We assume any repeated names are lists
+ (let ((prev (plist-get (ada-prj-plist project) (intern name))))
+ (if prev
+ (setf (ada-prj-plist project)
+ (plist-put (ada-prj-plist project)
+ (intern name)
+ (append (if (listp prev) prev (list prev))
+ (list value))))
+
+ (setf (ada-prj-plist project)
+ (plist-put
+ (ada-prj-plist project)
+ (intern name)
+ value)))
+ ))
+
+;; This is autoloaded because it is often used in Makefiles, and thus
+;; will be the first ada-mode function executed.
+;;;###autoload
+(defun ada-select-prj-file (prj-file)
+ ;; not ada-prj-select-file for backward compatibility
+ "Select PRJ-FILE as the current project file, parsing it if necessary.
+Deselects the current project first."
+ (wisi-prj-select-cache prj-file (ada-prj-default "")))
+(make-obsolete 'ada-select-prj-file 'wisi-prj-select-cache "ada-mode 7.0")
+
+(cl-defgeneric ada-prj-select-compiler (compiler project)
+ "PROJECT has been selected; set any project options that are both Ada and
compiler specific.")
+
+(cl-defgeneric ada-prj-deselect-compiler (compiler project)
+ "PROJECT has been deselected; unset any project options that are both Ada
and compiler specific.")
+
+(cl-defmethod wisi-prj-select :after ((project ada-prj))
+ (ada-prj-select-compiler (ada-prj-compiler project) project))
+
+(cl-defmethod wisi-prj-deselect :before ((project ada-prj))
+ (ada-prj-deselect-compiler (ada-prj-compiler project) project))
+
+(cl-defmethod wisi-prj-identifier-at-point ((_project ada-prj))
+ ;; Handle adjacent operator/identifer like:
+ ;; test/ada_mode-slices.adb
+ ;; D1, D2 : Day := +Sun;
+ ;;
+ ;; For operators, return quoted operator, for gpr_query or gnatfind.
+
+ (cond
+ ((wisi-in-comment-p)
+ (error "Inside comment"))
+
+ ((wisi-in-string-p)
+ ;; In an operator, or a string literal
+ (skip-chars-backward "+*/&<>=-")
+ (cond
+ ((and (= (char-before) ?\")
+ (progn
+ (forward-char -1)
+ (looking-at (concat "\"\\(" ada-operator-re "\\)\""))))
+ (concat "\"" (match-string-no-properties 1) "\""))
+
+ (t
+ (error "Inside string or character constant"))
+ ))
+
+ ((looking-at (concat "\"\\(" ada-operator-re "\\)\""))
+ (match-string-no-properties 0))
+
+ ((looking-at ada-operator-re)
+ (concat "\"" (match-string-no-properties 0) "\""))
+
+ ((memq (syntax-class (syntax-after (point))) '(2 3))
+ ;; word or symbol syntax.
+ (skip-syntax-backward "w_")
+ (buffer-substring-no-properties (point) (save-excursion
(skip-syntax-forward "w_") (point))))
+
+ (t
+ (error "No identifier around"))
+ ))
+
+;;;; initialization
+(push (cons "adp" #'wisi-prj-parse-file-1) wisi-prj-parser-alist)
+
+(add-to-list 'wisi-prj-file-extensions "adp")
+
+(provide 'ada-core)
+;; ada-core.el ends here
diff --git a/packages/ada-mode/ada-fix-error.el
b/packages/ada-mode/ada-fix-error.el
deleted file mode 100644
index cf90a59..0000000
--- a/packages/ada-mode/ada-fix-error.el
+++ /dev/null
@@ -1,237 +0,0 @@
-;;; ada-fix-error.el --- utilities for automatically fixing -*-
lexical-binding:t -*-
-;; errors reported by the compiler.
-
-;; Copyright (C) 1999-2009, 2012-2015, 2017-2019 Free Software Foundation, Inc.
-
-;; Author : Stephen Leake <address@hidden>
-;; Maintainer : Stephen Leake <address@hidden>
-;; Web site : http://www.stephe-leake.org/
-;; Keywords : languages ada error
-
-;; This file is part of GNU Emacs
-
-;; This program is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 3, or (at your option)
-;; any later version.
-
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING. If not, write to
-;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
-;;;; code
-
-(require 'ada-mode)
-(require 'cl-lib)
-(require 'compile)
-
-(defcustom ada-fix-sort-context-clause t
- "*If non-nil, sort context clause when inserting `with'"
- :type 'boolean
- :group 'ada)
-
-(defvar ada-fix-context-clause nil
- "Function to return the region containing the context clause for the current
buffer,
-excluding leading pragmas. Called with no arguments;
-return (BEGIN . END). BEGIN and END must be at beginning of line.
-If there is no context clause, BEGIN = END, at start of
-compilation unit.")
-
-(defun ada-fix-context-clause ()
- (when ada-fix-context-clause
- (funcall ada-fix-context-clause)))
-
-(defun ada-fix-insert-unit-name (unit-name)
- "Insert UNIT-NAME at point and capitalize it."
- ;; unit-name is normally gotten from a file-name, and is thus all lower-case.
- (let ((start-point (point))
- search-bound)
- (insert unit-name)
- (setq search-bound (point))
- (insert " ") ; separate from following words, if any, for
ada-case-adjust-identifier
- (goto-char start-point)
- (while (search-forward "." search-bound t)
- (forward-char -1)
- (ada-case-adjust-identifier)
- (forward-char 1))
- (goto-char search-bound)
- (ada-case-adjust-identifier)
- (delete-char 1)))
-
-(defun ada-fix-sort-context-pred (a b)
- "Predicate for `sort-subr'; sorts \"limited with\", \"private with\" last.
-Returns non-nil if a should preceed b in buffer."
- ;; a, b are buffer ranges in the current buffer
- (cl-flet
- ((starts-with
- (pat reg)
- (string= pat (buffer-substring-no-properties (car reg)
- (min (point-max)
- (+(car reg) (length
pat)))))))
- (cond
- ((and
- (starts-with "limited with" a)
- (starts-with "private with" b))
- t)
-
- ((and
- (starts-with "limited with" a)
- (not (starts-with "limited with" b)))
- nil)
-
- ((and
- (not (starts-with "limited with" a))
- (starts-with "limited with" b))
- t)
-
- ((and
- (starts-with "private with" a)
- (not (starts-with "private with" b)))
- nil)
-
- ((and
- (not (starts-with "private with" a))
- (starts-with "private with" b))
- t)
-
- (t
- (> 0 (compare-buffer-substrings
- nil (car a) (cdr a)
- nil (car b) (cdr b))) )
- )))
-
-(defun ada-fix-sort-context-clause (beg end)
- "Sort context clauses in range BEG END."
- (save-excursion
- (save-restriction
- (narrow-to-region beg end)
- (goto-char (point-min))
- (sort-subr nil 'forward-line 'end-of-line nil nil
'ada-fix-sort-context-pred)
- )))
-
-(defun ada-fix-add-with-clause (package-name)
- "Add a with_clause for PACKAGE_NAME.
-If ada-fix-sort-context-clause, sort the context clauses using
-sort-lines."
- (let ((context-clause (ada-fix-context-clause)))
- (when (not context-clause)
- (error "no compilation unit found"))
-
- (goto-char (cdr context-clause))
- (insert "with ")
- (ada-fix-insert-unit-name package-name)
- (insert ";\n")
-
- (when (and (< (car context-clause) (cdr context-clause))
- ada-fix-sort-context-clause)
- (ada-fix-sort-context-clause (car context-clause) (point)))
- ))
-
-(defun ada-fix-extend-with-clause (child-name)
- "Assuming point is in a selected name, just before CHILD-NAME, add or
-extend a with_clause to include CHILD-NAME . "
- (let ((parent-name-end (point)))
- ;; Find the full parent name; skip back to whitespace, then match
- ;; the name forward.
- (skip-syntax-backward "w_.")
- (search-forward-regexp ada-name-regexp parent-name-end)
- (let ((parent-name (match-string 0))
- (context-clause (ada-fix-context-clause)))
- (goto-char (car context-clause))
- (if (search-forward-regexp (concat "^with " parent-name ";") (cdr
context-clause) t)
- ;; found exisiting 'with' for parent; extend it
- (progn
- (forward-char -1) ; skip back over semicolon
- (insert "." child-name))
-
- ;; not found; we are in a package body, with_clause for parent is in
spec.
- ;; insert a new one
- (ada-fix-add-with-clause (concat parent-name "." child-name)))
- )))
-
-(defun ada-fix-add-use-type (type)
- "Insert `use type' clause for TYPE at start of declarative part for current
construct."
- (ada-goto-declarative-region-start); leaves point after 'is'
- (newline-and-indent)
- (cl-ecase ada-language-version
- (ada2012
- (insert "use all type "))
- ((ada83 ada95 ada2005)
- (insert "use type ")))
- (let ((begin (point))
- end)
- (insert type ";")
- (setq end (point))
- (goto-char begin)
- (while (< (point) end)
- (ada-case-adjust-at-point)
- (forward-char 1))
- ))
-
-(defun ada-fix-add-use (package)
- "Insert `use' clause for PACKAGE at start of declarative part for current
construct."
- (ada-goto-declarative-region-start); leaves point after 'is'
- (newline-and-indent)
- (insert "use " package ";"))
-
-(defvar ada-fix-error-hook nil
- ;; determined by ada_compiler, set by *-select-prj-compiler
- "Hook to recognize and fix errors.
-Hook functions are called with three args:
-
-MSG, the `compilation--message' struct for the current error
-
-SOURCE-BUFFER, the buffer containing the source to be fixed
-
-SOURCE-WINDOW, the window displaying SOURCE-BUFFER.
-
-Point in SOURCE-BUFFER is at error location; point in
-`compilation-last-buffer' is at MSG location. Focus is in
-compilation buffer.
-
-Hook functions should return t if the error is recognized and
-fixed, leaving point at fix. Otherwise, they should preserve
-point and return nil.")
-
-(defun ada-get-compilation-message ()
- "Get compilation message at line beginning."
- (get-text-property (line-beginning-position) 'compilation-message))
-
-;;;###autoload
-(defun ada-fix-compiler-error ()
- "Attempt to fix the current compiler error. Leave point at fixed code."
- (interactive)
-
- (let ((source-buffer (current-buffer))
- (source-window (selected-window))
- (line-move-visual nil)); screws up next-line otherwise
-
- (with-current-buffer compilation-last-buffer
- (when (not (ada-get-compilation-message))
- (beep)
- (message "ada-fix-compiler-error")
- ;; not clear why this can happen, but it has
- (compilation-next-error 1))
- (let ((comp-buf-pt (point))
- (success
- (run-hook-with-args-until-success
- 'ada-fix-error-hook
- (compilation-next-error 0)
- source-buffer
- source-window)))
- ;; restore compilation buffer point
- (set-buffer compilation-last-buffer)
- (goto-char comp-buf-pt)
-
- (unless success
- ;; none of the hooks handled the error
- (error "error not recognized"))
- ))))
-
-(provide 'ada-fix-error)
-;; end of file
diff --git a/packages/ada-mode/ada-gnat-xref.el
b/packages/ada-mode/ada-gnat-xref.el
index f95789d..80ba7ce 100644
--- a/packages/ada-mode/ada-gnat-xref.el
+++ b/packages/ada-mode/ada-gnat-xref.el
@@ -5,7 +5,7 @@
;;
;; GNAT is provided by AdaCore; see http://libre.adacore.com/
;;
-;;; Copyright (C) 2012 - 2018 Free Software Foundation, Inc.
+;;; Copyright (C) 2012 - 2020 Free Software Foundation, Inc.
;;
;; Author: Stephen Leake <address@hidden>
;; Maintainer: Stephen Leake <address@hidden>
@@ -33,17 +33,52 @@
;; By default, ada-mode is configured to load this file, so nothing
;; special needs to done to use it.
-(require 'ada-fix-error)
(require 'compile)
(require 'gnat-core)
-(defvar ada-gnat-debug-run);; gnat-core requires ada-mode, which requires
ada-gnat-xref
;;;;; code
;;;; uses of gnat tools
+(defconst gnatxref-buffer-name-prefix "*gnatxref-")
+
(defconst ada-gnat-file-line-col-regexp "\\(.*\\):\\([0-9]+\\):\\([0-9]+\\)")
+(defconst ada-gnat-file-line-col-type-regexp
+ (concat ada-gnat-file-line-col-regexp ": +\\(?:(\\(.*\\))\\)?")
+ "Regexp matching <file>:<line>:<column> (<type>)")
+
+(cl-defstruct (gnatxref-xref (:include gnat-compiler))
+ ;; no new slots
+ )
+
+;;;###autoload
+(cl-defun create-gnat-xref
+ (&key
+ gpr-file
+ run-buffer-name
+ project-path
+ target
+ runtime
+ gnat-stub-opts
+ gnat-stub-cargs)
+ ;; See note on `create-ada-prj' for why this is not a defalias.
+ (make-gnatxref-xref
+ :gpr-file gpr-file
+ :run-buffer-name run-buffer-name
+ :project-path project-path
+ :target target
+ :runtime runtime
+ :gnat-stub-opts gnat-stub-opts
+ :gnat-stub-cargs gnat-stub-cargs
+ ))
+
+(cl-defmethod wisi-xref-parse-one ((xref gnatxref-xref) project name value)
+ (wisi-compiler-parse-one xref project name value))
+
+(cl-defmethod wisi-xref-parse-final ((xref gnatxref-xref) _project
prj-file-name)
+ (setf (gnat-compiler-run-buffer-name xref) (gnat-run-buffer-name
prj-file-name gnatxref-buffer-name-prefix)))
+
(defun ada-gnat-xref-adj-col (identifier col)
"Return COL adjusted for 1-index, quoted operators."
(cond
@@ -73,33 +108,75 @@
(+ 1 col))
))
-(defun ada-gnat-xref-common-cmd ()
+(defun ada-gnat-xref-common-cmd (project)
"Returns the gnatfind command to run to find cross-references."
- (format "%sgnatfind" (or (ada-prj-get 'target) "")))
+ (format "%sgnatfind" (or (gnat-compiler-target (wisi-prj-xref project)) "")))
-(defun ada-gnat-xref-common-args (identifier file line col)
- "Returns a list of arguments to pass to gnatfind. The caller
-may add more args to the result before calling gnatfind. Some
+(defun ada-gnat-xref-common-args (project identifier file line col)
+ "Returns a list of arguments to pass to gnatfind. Some
elements of the result may be nil."
(list "-a"
- (when ada-xref-full-path "-f")
- ;; src_dir contains Source_Dirs from gpr_file, Similarly for
- ;; obj_dir. So we don't need to pass the gpr file.
- (when (ada-prj-get 'src_dir)
- (concat "-aI" (mapconcat 'identity (ada-prj-get 'src_dir) (if (eq
system-type 'windows-nt) ";" ":"))))
- (when (ada-prj-get 'obj_dir)
- (concat "-aO" (mapconcat 'identity (ada-prj-get 'obj_dir) (if (eq
system-type 'windows-nt) ";" ":"))))
+ (when wisi-xref-full-path "-f")
+ ;; 'gnatfind' does not take a gnat project file argument. We
+ ;; assue you are not using gnatxref if you are using a gnat
+ ;; project file; use gpr_query.
+ (when (wisi-prj-source-path project)
+ (concat "-aI" (mapconcat 'identity (wisi-prj-source-path project) "
-aI")))
+ (when (plist-get (ada-prj-plist project) 'obj_dir)
+ (concat "-aO" (mapconcat 'identity (plist-get (ada-prj-plist
project) 'obj_dir) " -aO")))
(format "%s:%s:%d:%d"
identifier
(file-name-nondirectory file)
line
(ada-gnat-xref-adj-col identifier col))))
-(defun ada-gnat-xref-other (identifier file line col)
- "For `ada-xref-other-function', using `gnatfind', which is Ada-specific."
- (let* ((result nil))
- (with-current-buffer (gnat-run-buffer)
- (gnat-run (ada-gnat-xref-common-cmd) (ada-gnat-xref-common-args
identifier file line col))
+(defun ada-gnat-xref-refs (project item all)
+ (with-slots (summary location) item
+ (with-slots (file line column) location
+ (let* ((wisi-xref-full-path t)
+ (args (cons "-r" (ada-gnat-xref-common-args project summary file
line column)))
+ (result nil))
+ (with-current-buffer (gnat-run-buffer project
(gnat-compiler-run-buffer-name (wisi-prj-xref project)))
+ (gnat-run project (ada-gnat-xref-common-cmd project) args)
+
+ (goto-char (point-min))
+ (when ada-gnat-debug-run (forward-line 2)); skip ADA_PROJECT_PATH,
'gnat find'
+
+ (while (not (eobp))
+ (cond
+ ((looking-at ada-gnat-file-line-col-type-regexp)
+ ;; process line
+ (let ((found-file (match-string 1))
+ (found-line (string-to-number (match-string 2)))
+ (found-col (string-to-number (match-string 3)))
+ (found-type (match-string 4)))
+ (when (or all found-type)
+ (push (xref-make (if found-type
+ (concat summary " " found-type)
+ summary)
+ (xref-make-file-location found-file
found-line found-col))
+ result))
+ ))
+ (t
+ ;; ignore line
+ ))
+ (forward-line 1)))
+ (nreverse result) ;; specs first.
+ ))))
+
+(cl-defmethod wisi-xref-definitions (_xref project item)
+ (ada-gnat-xref-refs project item nil))
+
+(cl-defmethod wisi-xref-references (_xref project item)
+ (ada-gnat-xref-refs project item t))
+
+(cl-defmethod wisi-xref-other ((_xref gnatxref-xref) project &key identifier
filename line column)
+ (let* ((wisi-xref-full-path t)
+ (cmd (ada-gnat-xref-common-cmd project))
+ (args (ada-gnat-xref-common-args project identifier filename line
column))
+ (result nil))
+ (with-current-buffer (gnat-run-buffer project
(gnat-compiler-run-buffer-name (wisi-prj-xref project)))
+ (gnat-run project cmd args)
(goto-char (point-min))
(when ada-gnat-debug-run (forward-line 2)); skip ADA_PROJECT_PATH, 'gnat
find'
@@ -118,14 +195,19 @@ elements of the result may be nil."
(let ((found-file (match-string 1))
(found-line (string-to-number (match-string 2)))
(found-col (string-to-number (match-string 3))))
+ ;; Sometimes gnatfind does not respect "-f" (test/ada_mode.ads
Separate_Procedure full body)
+ (unless (file-name-absolute-p found-file)
+ (setq found-file (locate-file found-file
compilation-search-path)))
+
(if (not
(and
;; due to symbolic links, only the non-dir filename is
comparable.
- (equal (file-name-nondirectory file) (file-name-nondirectory
found-file))
+ (equal (file-name-nondirectory filename)
(file-name-nondirectory found-file))
(= line found-line)
- (= (ada-gnat-xref-adj-col identifier col) found-col)))
- ;; found other item
+ (= (ada-gnat-xref-adj-col identifier column) found-col)))
+ ;; Found other item.
(setq result (list found-file found-line (1- found-col)))
+ ;; else keep searching
(forward-line 1))
))
@@ -134,13 +216,11 @@ elements of the result may be nil."
))
result))
-(defun ada-gnat-xref-parents (identifier file line col)
- "For `ada-xref-parents-function', using `gnatfind', which is Ada-specific."
-
- (let* ((arg (ada-gnat-xref-common-args identifier file line col))
+(cl-defmethod wisi-xref-parents ((_xref gnatxref-xref) project &key identifier
filename line column)
+ (let* ((arg (ada-gnat-xref-common-args project identifier filename line
column))
(result nil))
- (with-current-buffer (gnat-run-buffer)
- (gnat-run (ada-gnat-xref-common-cmd) (cons "-d" arg))
+ (with-current-buffer (gnat-run-buffer project
(gnat-compiler-run-buffer-name (wisi-prj-xref project)))
+ (gnat-run project (ada-gnat-xref-common-cmd project) (cons "-d" arg))
(goto-char (point-min))
(when ada-gnat-debug-run (forward-line 2)); skip GPR_PROJECT_PATH, 'gnat
find'
@@ -169,33 +249,32 @@ elements of the result may be nil."
(error "gnat find did not return parent types"))
))
- (ada-goto-source (nth 0 result)
- (nth 1 result)
- (nth 2 result))
+ (wisi-goto-source (nth 0 result)
+ (nth 1 result)
+ (nth 2 result))
))
-(defun ada-gnat-xref-all (identifier file line col local-only append)
- "For `ada-xref-all-function'."
+(cl-defmethod wisi-xref-all ((_xref gnatxref-xref) project &key identifier
filename line column local-only append)
;; we use `compilation-start' to run gnat, not `gnat-run', so it
;; is asynchronous, and automatically runs the compilation error
;; filter.
- (let* ((arg (ada-gnat-xref-common-args identifier file line col)))
+ (let* ((arg (ada-gnat-xref-common-args project identifier filename line
column)))
(setq arg (cons "-r" arg))
- (when local-only (setq arg (append arg (list file))))
+ (when local-only (setq arg (append arg (list filename))))
- (with-current-buffer (gnat-run-buffer); for default-directory
+ (with-current-buffer (gnat-run-buffer project
(gnat-compiler-run-buffer-name (wisi-prj-xref project)))
(let ((compilation-buffer-name "*gnatfind*")
(compilation-error "reference")
(command-and-args (mapconcat (lambda (a) (or a ""))
- (cons (ada-gnat-xref-common-cmd) arg)
+ (cons (ada-gnat-xref-common-cmd
project) arg)
" "))
;; gnat find uses standard gnu format for output, so don't
;; need to set compilation-error-regexp-alist
prev-pos
prev-content)
- ;; compilation-environment is buffer-local; don't set in 'let'
- (setq compilation-environment (ada-prj-get 'proc_env))
+
+ ;; compilation-environment is set in `wisi-prj-select'
;; WORKAROUND: the 'compilation' API doesn't let us specify "append",
so we use this.
(with-current-buffer (get-buffer-create compilation-buffer-name)
@@ -208,7 +287,7 @@ elements of the result may be nil."
(setq command-and-args
(propertize command-and-args
'display
- (format "References to %s at %s:%d:%d" identifier
file line col))))
+ (format "References to %s at %s:%d:%d" identifier
filename line column))))
(compilation-start command-and-args
'compilation-mode
(lambda (_name) compilation-buffer-name))
@@ -219,52 +298,11 @@ elements of the result may be nil."
(goto-char prev-pos))))
))))
-;;;;; setup
-
-(defun ada-gnat-xref-select-prj ()
- (setq ada-file-name-from-ada-name 'ada-gnat-file-name-from-ada-name)
- (setq ada-ada-name-from-file-name 'ada-gnat-ada-name-from-file-name)
- (setq ada-make-package-body 'ada-gnat-make-package-body)
-
- (setq ada-xref-other-function 'ada-gnat-xref-other)
- (setq ada-xref-parent-function 'ada-gnat-xref-parents)
- (setq ada-xref-all-function 'ada-gnat-xref-all)
- (setq ada-show-xref-tool-buffer 'ada-gnat-show-run-buffer)
-
- ;; gnatmake -gnatD generates files with .dg extensions. But we don't
- ;; need to navigate between them.
-
- (add-to-list 'completion-ignored-extensions ".ali") ;; gnat library files,
used for cross reference
- (add-to-list 'compilation-error-regexp-alist 'gnat)
- )
-
-(defun ada-gnat-xref-deselect-prj ()
- (setq ada-file-name-from-ada-name nil)
- (setq ada-ada-name-from-file-name nil)
- (setq ada-make-package-body nil)
+(cl-defmethod wisi-xref-overriding ((_xref gnatxref-xref) _project &key
_identifier _filename _line _column)
+ (error "gnatxref does not support 'show overriding' - use gpr_query?"))
- (setq ada-xref-other-function nil)
- (setq ada-xref-parent-function nil)
- (setq ada-xref-all-function nil)
- (setq ada-show-xref-tool-buffer nil)
-
- (setq completion-ignored-extensions (delete ".ali"
completion-ignored-extensions))
- (setq compilation-error-regexp-alist (delete 'gnat
compilation-error-regexp-alist))
- )
-
-(defun ada-gnat-xref ()
- "Set Ada mode global vars to use 'gnat xref'"
- (add-to-list 'ada-prj-file-ext-extra "gpr")
- (add-to-list 'ada-prj-parser-alist '("gpr" . gnat-parse-gpr))
- (add-to-list 'ada-select-prj-xref-tool '(gnat . ada-gnat-xref-select-prj))
- (add-to-list 'ada-deselect-prj-xref-tool '(gnat .
ada-gnat-xref-deselect-prj))
-
- ;; no parse-*-xref yet
-
- (add-hook 'ada-gnat-fix-error-hook 'ada-gnat-fix-error))
-
-(ada-gnat-xref)
+(cl-defmethod wisi-xref-overridden ((_xref gnatxref-xref) _project &key
_identifier _filename _line _column)
+ (error "gnatxref does not support 'show overridden' - use gpr_query?"))
(provide 'ada-gnat-xref)
-
;; end of file
diff --git a/packages/ada-mode/ada-imenu.el b/packages/ada-mode/ada-imenu.el
index f5af9e1..06d9595 100644
--- a/packages/ada-mode/ada-imenu.el
+++ b/packages/ada-mode/ada-imenu.el
@@ -1,6 +1,6 @@
;;; ada-imenu.el - Ada mode interface to imenu for Ada Mode -*-
lexical-binding:t -*-
-;; Copyright (C) 2012, 2013, 2015 Free Software Foundation, Inc.
+;; Copyright (C) 2012, 2013, 2015, 2019 Free Software Foundation, Inc.
;;
;; Author: Simon Wright <address@hidden>
;; Contributors: see ada-mode.el, and specifically Christian Egli
@@ -24,7 +24,7 @@
;;; History: see ada_mode.el
;;
-(require 'ada-mode)
+(require 'ada-core)
(require 'imenu)
(defconst ada--imenu-comment-re "\\([ \t]*--.*\\)?")
diff --git a/packages/ada-mode/ada-indent-user-options.el
b/packages/ada-mode/ada-indent-user-options.el
index b4d309c..3f58573 100644
--- a/packages/ada-mode/ada-indent-user-options.el
+++ b/packages/ada-mode/ada-indent-user-options.el
@@ -39,18 +39,7 @@ begin
:safe #'integerp)
(make-variable-buffer-local 'ada-indent)
-(defvar ada-broken-indent nil)
-(make-obsolete-variable
- 'ada-broken-indent
- 'ada-indent-broken
- "Emacs 24.4, Ada mode 5.0")
-
-(defcustom ada-indent-broken
- (if ada-broken-indent
- (progn
- (message "WARNING: setting `ada-indent-broken' to obsolete
`ada-broken-indent'")
- ada-broken-indent)
- 2)
+(defcustom ada-indent-broken 2
"Indentation for the continuation of a broken line.
Example :
@@ -80,22 +69,7 @@ Otherwise, they are indented as a with previous comments or
code."
:safe #'booleanp)
(make-variable-buffer-local 'ada-indent-comment-gnat)
-(defvar ada-label-indent nil)
-(make-obsolete-variable
- 'ada-label-indent
- 'ada-indent-label
- "Emacs 24.4, Ada mode 5.0")
-
-(defcustom ada-indent-label
- (if ada-label-indent
- (progn
- (message "WARNING: setting `ada-indent-label' to obsolete
`ada-label-indent'")
- ada-label-indent)
- -3)
- ;; Ada mode 4.01 and earlier default this to -4. But that is
- ;; incompatible with the default gnat indentation style check, which
- ;; wants all indentations to be a multiple of 3 (with some
- ;; exceptions). So we default this to -3.
+(defcustom ada-indent-label -3
"Indentation for a loop, block, or statement label, relative to the item it
labels.
Example :
@@ -164,18 +138,7 @@ An example is:
:safe #'integerp)
(make-variable-buffer-local 'ada-indent-return)
-(defvar ada-use-indent nil)
-(make-obsolete-variable
- 'ada-use-indent
- 'ada-indent-use
- "Emacs 24.4, Ada mode 5.0")
-
-(defcustom ada-indent-use
- (if ada-use-indent
- (progn
- (message "WARNING: setting `ada-indent-use' to obsolete
`ada-use-indent'")
- ada-use-indent)
- ada-indent-broken)
+(defcustom ada-indent-use ada-indent-broken
"Indentation for the lines in a `use' statement.
An example is:
@@ -185,18 +148,7 @@ An example is:
:safe #'integerp)
(make-variable-buffer-local 'ada-indent-use)
-(defvar ada-when-indent nil)
-(make-obsolete-variable
- 'ada-when-indent
- 'ada-indent-when
- "Emacs 24.4, Ada mode 5.0")
-
-(defcustom ada-indent-when
- (if ada-when-indent
- (progn
- (message "WARNING: setting `ada-indent-when' to obsolete
`ada-when-indent'")
- ada-when-indent)
- 3)
+(defcustom ada-indent-when 3
"Indentation for `when' relative to `exception', `case', `or' in select.
An example is:
@@ -206,18 +158,7 @@ An example is:
:safe #'integerp)
(make-variable-buffer-local 'ada-indent-when)
-(defvar ada-with-indent nil)
-(make-obsolete-variable
- 'ada-with-indent
- 'ada-indent-with
- "Emacs 24.4, Ada mode 5.0")
-
-(defcustom ada-indent-with
- (if ada-with-indent
- (progn
- (message "WARNING: setting `ada-indent-with' to obsolete
`ada-with-indent'")
- ada-with-indent)
- ada-indent-broken)
+(defcustom ada-indent-with ada-indent-broken
"Indentation for the lines in a `with' context clause.
An example is:
diff --git a/packages/ada-mode/ada-mode-compat.el
b/packages/ada-mode/ada-mode-compat.el
deleted file mode 100644
index f244d86..0000000
--- a/packages/ada-mode/ada-mode-compat.el
+++ /dev/null
@@ -1,27 +0,0 @@
-;; ada-mode-compat.el --- Implement current Emacs features not present earlier
versions -*- lexical-binding:t -*-
-
-;; Copyright (C) 2014-2017 Free Software Foundation, Inc.
-
-;; This file is part of GNU Emacs.
-
-;; GNU Emacs is free software: you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; GNU Emacs is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
-
-(when (not (functionp 'font-lock-ensure))
- ;; not in 24.3, 24.4, 24.5; in 25.1
- (defun font-lock-ensure (&optional beg end)
- (font-lock-fontify-region (or beg (point-min)) (or end (point-max)))))
-
-(provide 'ada-mode-compat)
-
-;; end of file
diff --git a/packages/ada-mode/ada-mode.el b/packages/ada-mode/ada-mode.el
index 3995491..1de8194 100644
--- a/packages/ada-mode/ada-mode.el
+++ b/packages/ada-mode/ada-mode.el
@@ -1,13 +1,13 @@
;;; ada-mode.el --- major-mode for editing Ada sources -*- lexical-binding:t
-*-
;;
-;; Copyright (C) 1994, 1995, 1997 - 2019 Free Software Foundation, Inc.
+;; Copyright (C) 1994, 1995, 1997 - 2020 Free Software Foundation, Inc.
;;
;; Author: Stephen Leake <address@hidden>
;; Maintainer: Stephen Leake <address@hidden>
;; Keywords: languages
;; ada
-;; Version: 6.2.1
-;; package-requires: ((uniquify-files "1.0.1") (wisi "2.2.1") (emacs "25.0"))
+;; Version: 7.0.1
+;; package-requires: ((uniquify-files "1.0.1") (wisi "3.0.1") (emacs "25.0"))
;; url: http://www.nongnu.org/ada-mode/
;;
;; This file is part of GNU Emacs.
@@ -34,86 +34,29 @@
;;
;; By default, ada-mode is configured to take full advantage of the
;; GNAT compiler. If you are using another compiler, you
-;; should load that compiler's ada-* file first; that will define
-;; ada-compiler as a feature, so ada-gnat.el will not be loaded.
+;; should load that compiler's ada-* file first.
;;
;; See the user guide (info "ada-mode"), built from ada-mode.texi.
;;; Design:
;;
-;; In order to support multiple compilers, we use indirect function
-;; calls for all operations that depend on the compiler.
+;; In order to support multiple compilers, and different compilers for
+;; different projects, we use cl-defgeneric function calls for all
+;; operations that depend on the compiler. The user variable
+;; `ada-compiler' selects which compiler to use; it can be overridden
+;; by the "ada_compiler" setting in project files.
;;
;; We also support a cross reference tool (also called xref tool) that
;; is different from the compiler. For example, you can use a local
;; GNAT compiler to generate and access cross-reference information,
-;; while using a cross-compiler for compiling the final executable.
+;; while using a cross-compiler for compiling the final
+;; executable. The user variable `ada-xref-tool' selects the xref
+;; tool; it can be overridden by the "xref_tool" setting in project
+;; files.
;;
-;; Other functions are lumped with the choice of xref tool; mapping
-;; Ada names to file names, creating package bodies; any tool function
-;; that does not create executable code.
+;; The indentation engine and skeleton tools are from the wisi
+;; package.
;;
-;; The indentation engine and skeleton tools are also called
-;; indirectly, to allow parallel development of new versions of these
-;; tools (inspired by experience with ada-smie and ada-wisi).
-;;
-;; We also support using different compilers for different projects;
-;; `ada-compiler' can be set in Ada mode project files. Note that
-;; there is only one project active at a time; the most recently
-;; selected one. All Ada files are assumed to belong to this project
-;; (which is not correct, but works well in practice; the user is
-;; typically only concerned about files that belong to the current
-;; project).
-;;
-;; There are several styles of indirect calls:
-;;
-;; - scalar global variable set during load
-;;
-;; Appropriate when the choice of implementation is fixed at load
-;; time; it does not depend on the current Ada project. Used for
-;; indentation and skeleton functions.
-;;
-;; - scalar global variable set during project select
-;;
-;; Appropriate when the choice of implementation is determined by
-;; the choice of compiler or xref tool, which is per-project. The
-;; user sets the compiler choice in the project file, but not the
-;; lower-level redirect choice.
-;;
-;; For example, `ada-file-name-from-ada-name' depends on the naming
-;; convention used by the compiler. If the project file sets
-;; ada_compiler to 'gnat (either directly or by default),
-;; ada-gnat-select-prj sets `ada-file-name-from-ada-name' to
-;; `ada-gnat-file-name-from-ada-name'.
-;;
-;; - scalar buffer-local variable set during project select or file open
-;;
-;; Appropriate when choice of implementation is normally
-;; per-project, but can be per-buffer.
-;;
-;; For example, `ada-case-strict' will normally be set by the
-;; project, but some files may deviate from the project standard (if
-;; they are generated by -fdumpspec, for example). Those files set
-;; `ada-case-strict' in a file local variable comment.
-;;
-;; - scalar buffer-local variable set by ada-mode or ada-mode-hook
-;; function
-;;
-;; Appropriate when the variable is a non-Ada mode variable, also
-;; used by other modes, and choice should not affect those modes.
-;;
-;; `indent-line-function', `comment-indent-function' use this style
-;;
-;; - alist global variable indexed by ada-compiler
-;;
-;; Appropriate when the choice of implementation is determined by
-;; the compiler, but the function is invoked during project parse,
-;; so we can't depend on a value set by project select.
-;;
-;; alist entries are set during load by the implementation elisp files.
-;;
-;; `ada-prj-default-compiler-alist' uses this style.
-
;;; History:
;;
;; The first Ada mode for GNU Emacs was written by V. Broman in
@@ -141,6 +84,9 @@
;; A complete rewrite, to restructure the code more orthogonally, and
;; to use wisi for the indentation engine, was done in 2012 - 2013 by
;; Stephen Leake <address@hidden>.
+;;
+;; Another major refactoring, to use cl-defgeneric dispatching, was
+;; done in 2019 by Stephen Leake.
;;; Credits:
;;
@@ -158,253 +104,114 @@
;; address@hidden
;; and others for their valuable hints.
+(require 'ada-core)
+(require 'ada-indent-user-options)
+(require 'ada-process)
+(require 'ada-skel)
(require 'align)
(require 'cl-lib)
(require 'compile)
(require 'find-file)
-(require 'wisi) ;; FIXME: rewrite to assume wisi
+(require 'wisi)
(defun ada-mode-version ()
"Return Ada mode version."
(interactive)
- (let ((version-string "6.2.1"))
- ;; must match:
- ;; ada-mode.texi
- ;; README-ada-mode
- ;; Version: above
+ (let ((version-string "7.0.1"))
(if (called-interactively-p 'interactive)
(message version-string)
version-string)))
;;;;; User variables
-(defvar ada-mode-hook nil
- "List of functions to call when Ada mode is invoked.
-This hook is executed after `ada-mode' is fully loaded, but
-before file local variables are processed.")
-
-(defgroup ada nil
- "Major mode for editing Ada source code in Emacs."
- :group 'languages)
-
-(defcustom ada-auto-case t
- "Buffer-local value that may override project variable `auto_case'.
-Global value is default for project variable `auto_case'.
-t means automatically change case of preceding word while typing.
-not-upper-case means only change case if typed word is not all upper-case.
-Casing of Ada keywords is done according to `ada-case-keyword',
-identifiers are Mixed_Case."
- :type '(choice (const nil)
- (const t)
- (const not-upper-case))
- :safe (lambda (val) (memq val '(nil t not-upper-case))))
-(make-variable-buffer-local 'ada-auto-case)
-
-(defcustom ada-case-exception-file nil
- "Default list of special casing exceptions dictionaries for identifiers.
-Override with `casing' project variable.
-
-New exceptions may be added interactively via `ada-case-create-exception'.
-If an exception is defined in multiple files, the first occurence is used.
-
-The file format is one word per line, that gives the casing to be
-used for that word in Ada source code. If the line starts with
-the character *, then the exception will be used for partial
-words that either start at the beginning of a word or after a _
-character, and end either at the end of the word or at a _
-character. Characters after the first word are ignored, and not
-preserved when the list is written back to the file."
- :type '(repeat (file))
- :safe #'listp)
-
-(defcustom ada-case-keyword 'lower-case
- "Buffer-local value that may override project variable `case_keyword'.
-Global value is default for project variable `case_keyword'.
-Indicates how to adjust the case of Ada keywords."
- :type '(choice (const lower-case)
- (const upper-case))
- ;; We'd like to specify that the value must be a function that takes
- ;; one arg, but custom doesn't support that. ':safe' is supposed
- ;; to be used to prevent user-provided functions from compromising
- ;; security, so ":safe #'functionp" is not appropriate. So we
- ;; use a symbol, and a cl-ecase in ada-case-keyword.
- :safe (lambda (val) (memq val '(lower-case upper-case)))
- )
-(make-variable-buffer-local 'ada-case-keyword)
-
-(defcustom ada-case-identifier 'mixed-case
- "Buffer-local value that may override project variable `case_keyword'.
-Global value is default for project variable `case_keyword'.
-Indicates how to adjust the case of Ada keywords.
-Called with three args;
-start - buffer pos of start of identifier
-end - end of identifier
-force-case - if t, treat `ada-case-strict' as t"
- :type '(choice (const mixed-case)
- (const lower-case)
- (const upper-case))
- ;; see comment on :safe at ada-case-keyword
- :safe (lambda (val) (memq val '(mixed-case lower-case upper-case)))
- )
-;; we'd like to check that there are 3 args, since the previous
-;; release required 2 here. But there doesn't seem to be a way to
-;; access the arg count, which is only available for byte-compiled
-;; functions
-(make-variable-buffer-local 'ada-case-identifier)
-
-(defcustom ada-case-strict t
- "Buffer-local value that may override project variable `case_strict'.
-Global value is default for project variable `case_strict'.
-If non-nil, force Mixed_Case for identifiers.
-Otherwise, allow UPPERCASE for identifiers."
- :type 'boolean
- :safe #'booleanp)
-(make-variable-buffer-local 'ada-case-strict)
-
-(defcustom ada-language-version 'ada2012
- "Ada language version; one of `ada83', `ada95', `ada2005', `ada2012'.
-Only affects the keywords to highlight, not which version the
-indentation parser accepts."
- :type '(choice (const ada83)
- (const ada95)
- (const ada2005)
- (const ada2012))
- :safe #'symbolp)
-(make-variable-buffer-local 'ada-language-version)
-
(defcustom ada-fill-comment-prefix "-- "
"Comment fill prefix."
+ :group 'ada
:type 'string)
(make-variable-buffer-local 'ada-fill-comment-prefix)
(defcustom ada-fill-comment-postfix " --"
"Comment fill postfix."
+ :group 'ada
:type 'string)
(make-variable-buffer-local 'ada-fill-comment-postfix)
(defcustom ada-fill-comment-adaptive nil
"If non-nil, comments are filled to the same width (not including
indentation),
rather than to the same column."
+ :group 'ada
:type 'boolean
:safe #'booleanp)
-(defcustom ada-prj-file-extensions '("adp" "prj")
- "List of Emacs Ada mode project file extensions.
-Used when searching for a project file.
-Any file with one of these extensions will be parsed by
`ada-prj-parse-file-1'."
- :type 'list)
-
-(defcustom ada-prj-file-ext-extra nil
- "List of secondary project file extensions.
-Used when searching for a project file that can be a primary or
-secondary project file (referenced from a primary). The user
-must provide a parser for a file with one of these extensions."
- :type 'list)
-
-(defcustom ada-prj-parse-hook nil
- "Hook run at start of `ada-parse-prj-file'.
-Useful for setting `ada-xref-tool' and similar vars."
- :type 'function
- :group 'ada)
-
-(defcustom ada-xref-full-path nil
- "If t, cross-references show the full path to source files; if
-nil, only the file name."
- :type 'boolean
- :safe #'booleanp)
+(defcustom ada-which-func-parse-size 30000
+ "Minimum size of the region surrounding point that is parsed for
`which-function-mode'."
+ :group 'ada
+ :type 'integer
+ :safe #'integerp)
-(defcustom ada-process-parse-exec "ada_mode_wisi_lr1_parse.exe"
- ;; We use .exe even on Linux to simplify the Makefile
+(defcustom ada-process-parse-exec "ada_mode_wisi_lr1_parse"
"Name of executable to use for external process Ada parser.
-There are two standard choices; ada_mode_wisi_lalr_parse.exe and
-ada_mode_wisi_lr1_parse.exe. The LR1 version (the default) is
+There are two standard choices; ada_mode_wisi_lalr_parse and
+ada_mode_wisi_lr1_parse. The LR1 version (the default) is
slower to load on first use, but gives better error recovery."
:type 'string
- :group 'ada-indentation)
+ :group 'ada)
(defcustom ada-process-parse-exec-opts nil
"List of process start options for `ada-process-parse-exec'."
:type 'string
- :group 'ada-indentation)
-
-(defcustom ada-which-func-parse-size 30000
- "Minimum size of the region surrounding point that is parsed for
`which-function-mode'."
- :type 'integer
- :safe #'integerp)
-
-;;;;; end of user variables
-
-(defconst ada-symbol-end
- ;; we can't just add \> here; that might match _ in a user modified
ada-mode-syntax-table
- "\\([ \t]+\\|$\\)"
- "Regexp to add to symbol name in `ada-which-function'.")
-
-(defvar ada-compiler nil
- "Default Ada compiler; can be overridden in project files.
-Values defined by compiler packages.")
+ :group 'ada)
-(defvar ada-xref-tool nil
- "Default Ada cross reference tool; can be overridden in project files.
-Values defined by cross reference packages.")
+(defcustom ada-xref-full-path nil
+ "If t, cross-references show the full path to source files; if
+nil, only the file name."
+ :group 'ada
+ :type 'boolean
+ :safe #'booleanp)
;;;; keymap and menus
-(defvar ada-ret-binding 'ada-indent-newline-indent)
-(defvar ada-lfd-binding 'newline-and-indent)
-
-(defun ada-case-activate-keys (map)
- "Modify the key bindings for all the keys that should adjust casing."
- ;; we could just put these in the keymap below, but this is easier.
- (mapc (function
- (lambda(key)
- (define-key
- map
- (char-to-string key)
- 'ada-case-adjust-interactive)))
- '( ?_ ?% ?& ?* ?\( ?\) ?- ?= ?+
- ?| ?\; ?: ?' ?\" ?< ?, ?. ?> ?/ ?\n 32 ?\r ))
- )
-
(defvar ada-mode-map
(let ((map (make-sparse-keymap)))
;; C-c <letter> are reserved for users
;; global-map has C-x ` 'next-error
- (define-key map [return] 'ada-case-adjust-interactive)
+ (define-key map [return] 'wisi-case-adjust-interactive)
(define-key map "\C-c`" 'ada-show-secondary-error)
(define-key map "\C-c;" (lambda () (error "use M-; instead"))) ;
comment-dwim
(define-key map "\C-c<" 'ada-goto-declaration-start)
(define-key map "\C-c>" 'ada-goto-declaration-end)
- (define-key map "\C-c\M-`" 'ada-fix-compiler-error)
+ (define-key map "\C-c\M-`" 'wisi-fix-compiler-error)
(define-key map "\C-c\C-a" 'ada-align)
(define-key map "\C-c\C-b" 'ada-make-subprogram-body)
(define-key map "\C-c\C-c" 'ada-build-make)
- (define-key map "\C-c\C-d" 'ada-goto-declaration)
- (define-key map "\C-c\M-d" 'ada-show-declaration-parents)
- (define-key map "\C-c\C-e" 'ada-expand)
- (define-key map "\C-c\C-f" 'ada-show-parse-error)
- (define-key map "\C-c\C-i" 'ada-indent-statement)
- (define-key map "\C-c\C-l" 'ada-show-local-references)
+ (define-key map "\C-c\C-d" 'wisi-goto-spec/body)
+ (define-key map "\C-c\M-d" 'wisi-show-declaration-parents)
+ (define-key map "\C-c\C-e" 'wisi-skel-expand)
+ (define-key map "\C-c\C-f" 'wisi-show-parse-error)
+ (define-key map "\C-c\C-i" 'wisi-indent-statement)
+ (define-key map [3 backtab] 'wisi-indent-containing-statement);; C-c
backtab, translated from C-c S-tab
+ (define-key map "\C-c\C-l" 'wisi-show-local-references)
(define-key map "\C-c\C-m" 'ada-build-set-make)
(define-key map "\C-c\C-n" 'forward-sexp)
- (define-key map "\C-c\M-n" 'ada-next-placeholder)
+ (define-key map "\C-c\M-n" 'wisi-skel-next-placeholder)
(define-key map "\C-c\C-o" 'ada-find-other-file)
- (define-key map "\C-c\M-o" 'ada-find-other-file-noset)
(define-key map "\C-c\C-p" 'backward-sexp)
- (define-key map "\C-c\M-p" 'ada-prev-placeholder)
- (define-key map "\C-c\C-q" 'ada-xref-refresh)
- (define-key map "\C-c\C-r" 'ada-show-references)
+ (define-key map "\C-c\M-p" 'wisi-skel-prev-placeholder)
+ (define-key map "\C-c\C-q" 'wisi-refresh-prj-cache)
+ (define-key map "\C-c\C-r" 'wisi-show-references)
(define-key map "\C-c\M-r" 'ada-build-run)
- (define-key map "\C-c\C-s" 'ada-goto-previous-pos)
+ (define-key map "\C-c\C-s" 'pop-global-mark)
+ (define-key map "\C-c\C-t" 'ada-find-file)
(define-key map "\C-c\C-v" 'ada-build-check)
- (define-key map "\C-c\C-w" 'ada-case-adjust-at-point)
- (define-key map "\C-c\C-x" 'ada-show-overriding)
- (define-key map "\C-c\M-x" 'ada-show-overridden)
- (define-key map "\C-c\C-y" 'ada-case-create-exception)
- (define-key map "\C-c\C-\M-y" 'ada-case-create-partial-exception)
+ (define-key map "\C-c\C-w" 'wisi-case-adjust-at-point)
+ (define-key map "\C-c\C-x" 'wisi-show-overriding)
+ (define-key map "\C-c\M-x" 'wisi-show-overridden)
+ (define-key map "\C-c\C-y" 'wisi-case-create-exception)
+ (define-key map "\C-c\C-\M-y" 'wisi-case-create-partial-exception)
(define-key map [C-down-mouse-3] 'ada-popup-menu)
- (ada-case-activate-keys map)
+ (wisi-case-activate-keys map)
map
) "Local keymap used for Ada mode.")
@@ -420,17 +227,16 @@ Values defined by cross reference packages.")
["Customize" (customize-group 'ada) t]
("Project files"
["Find and select project ..." ada-build-prompt-select-prj-file t]
- ["Select project ..." ada-prj-select t]
- ["Show project" ada-prj-show t]
- ["Show project file search path" ada-prj-show-prj-path t]
- ["Show source file search path" ada-prj-show-src-path t]
- ["Delete project ..." ada-prj-delete t]
+ ["Show project" wisi-prj-show t]
+ ["Show project file search path" wisi-prj-show-prj-path t]
+ ["Show source file search path" wisi-prj-show-src-path t]
+ ["Clear current project" wisi-prj-clear-current t]
)
("Build"
["Next compilation error" next-error t]
["Show secondary error" ada-show-secondary-error t]
- ["Fix compilation error" ada-fix-compiler-error t]
- ["Show last parse error" ada-show-parse-error t]
+ ["Fix compilation error" wisi-fix-compiler-error t]
+ ["Show last parse error" wisi-show-parse-error t]
["Check syntax" ada-build-check t]
["Show main" ada-build-show-main t]
["Build" ada-build-make t]
@@ -439,28 +245,31 @@ Values defined by cross reference packages.")
)
("Navigate"
["Other file" ada-find-other-file t]
- ["Other file don't find decl" ada-find-other-file-noset t]
- ["Find file in project" ada-find-file t]
- ["Goto declaration/body" ada-goto-declaration t]
+ ["Find file in project" project-find-file t]
+ ["Goto declaration/body" wisi-goto-spec/body t]
["Goto next statement keyword" forward-sexp t]
["Goto prev statement keyword" backward-sexp t]
+ ["Goto subprogram/package start" ada-goto-declaration-start t]
+ ["Goto subprogram/package end" ada-goto-declaration-end t]
["Goto declarative region start" ada-goto-declarative-region-start t]
- ["Goto declaration start" ada-goto-declaration-start t]
- ["Goto declaration end" ada-goto-declaration-end t]
- ["Show parent declarations" ada-show-declaration-parents t]
- ["Show references" ada-show-references t]
- ["Show overriding" ada-show-overriding t]
- ["Show overridden" ada-show-overridden t]
- ["Goto secondary error" ada-show-secondary-error t]
- ["Goto prev position" ada-goto-previous-pos t]
- ["Next placeholder" ada-next-placeholder t]
- ["Previous placeholder" ada-prev-placeholder t]
+ ["Goto containing statement start" wisi-goto-containing-statement-start t]
+ ["Show parent declarations" wisi-show-declaration-parents t]
+ ["Show all references (classwide)" xref-find-references t]
+ ["Show all direct references" wisi-show-references t]
+ ["Show local references" wisi-show-local-references t]
+ ["Show overriding" wisi-show-overriding t]
+ ["Show overridden" wisi-show-overridden t]
+ ["Goto prev position current buffer" pop-to-mark-command t]
+ ["Goto prev position other buffer" pop-global-mark t]
+ ["Next placeholder" wisi-skel-next-placeholder t]
+ ["Previous placeholder" wisi-skel-prev-placeholder t]
)
("Edit"
- ["Expand skeleton" ada-expand t]
+ ["Expand skeleton" wisi-skel-expand t]
["Indent line or selection" indent-for-tab-command t]
- ["Indent current statement" ada-indent-statement t]
- ["Indent lines in file" (indent-region (point-min) (point-max)) t]
+ ["Indent current statement" wisi-indent-statement t]
+ ["Indent containing statement" wisi-indent-containing-statement t]
+ ["Indent file" (indent-region (point-min) (point-max)) t]
["Align" ada-align t]
["Comment/uncomment selection" comment-dwim t]
["Fill comment paragraph" ada-fill-comment-paragraph t]
@@ -469,87 +278,54 @@ Values defined by cross reference packages.")
["Make body for subprogram" ada-make-subprogram-body t]
)
("Refactor"
- ["Method (Object) => Object.Method" ada-wisi-refactor-1 t]
- ["Object.Method => Method (Object)" ada-wisi-refactor-2 t]
- ["Element (Object, Index) => Object (Index)" ada-wisi-refactor-3 t]
- ["Object (Index) => Element (Object, Index)" ada-wisi-refactor-4 t]
+ ["Method (Object) => Object.Method" ada-refactor-1 t]
+ ["Object.Method => Method (Object)" ada-refactor-2 t]
+ ["Element (Object, Index) => Object (Index)" ada-refactor-3 t]
+ ["Object (Index) => Element (Object, Index)" ada-refactor-4 t]
)
("Casing"
- ["Create full exception" ada-case-create-exception t]
- ["Create partial exception" ada-case-create-partial-exception t]
- ["Adjust case at point" ada-case-adjust-at-point t]
- ["Adjust case region" ada-case-adjust-region t]
- ["Adjust case buffer" ada-case-adjust-buffer t]
- ["Show casing files list" ada-case-show-files t]
+ ["Create full exception" wisi-case-create-exception t]
+ ["Create partial exception" wisi-case-create-partial-exception t]
+ ["Adjust case at point" wisi-case-adjust-at-point t]
+ ["Adjust case region" wisi-case-adjust-region t]
+ ["Adjust case buffer" wisi-case-adjust-buffer t]
+ ["Show casing files list" wisi-case-show-files t]
)
("Misc"
- ["Show last parse error" ada-show-parse-error t]
- ["Show xref tool buffer" ada-show-xref-tool-buffer t]
- ["Refresh cross reference cache" ada-xref-refresh t]
- ["Reset parser" ada-reset-parser t]
+ ["Show last parse error" wisi-show-parse-error t]
+ ["Refresh cross reference cache" ada-xref-refresh t]
+ ["Restart parser" wisi-kill-parser t]
)))
-(defun ada-project-menu-compute ()
- "Return an easy-menu menu for `ada-project-menu-install'.
-Menu displays currently parsed Ada mode projects."
- (let (menu)
- (dolist (item ada-prj-alist)
- (push
- (vector
- (if (equal (car item) ada-prj-current-file)
- ;; current project
- (concat (car item) " *")
- (car item))
- `(lambda () (interactive) (ada-select-prj-file ,(car item)))
- t)
- menu)
- )
- (nreverse menu)))
-
-(defun ada-project-menu-install ()
- "Install the Ada project menu as a submenu."
- (when (eq major-mode 'ada-mode)
- (lookup-key ada-mode-map [menu-bar Ada]) ;; map to put menu in
- [ada-prj-select] ;; key to insert (a menu entry)
- (easy-menu-binding
- (easy-menu-create-menu
- "Select Project"
- (ada-project-menu-compute)));; binding
- nil;; after
-
- ;; IMPROVEME: this doesn’t work for ’after’; "Select Project" is at end
- ;; (lookup-key ada-mode-map [menu-bar Ada Build])
- ))
-
(easy-menu-define ada-context-menu nil
"Context menu keymap for Ada mode"
'("Ada"
- ["Goto declaration/body" ada-goto-declaration t]
- ["Show parent declarations" ada-show-declaration-parents t]
- ["Goto declarative region start" ada-goto-declarative-region-start t]
- ["Goto declaration start" ada-goto-declaration-start t]
- ["Goto declaration end" ada-goto-declaration-end t]
- ["Show parent declarations" ada-show-declaration-parents t]
- ["Show references" ada-show-references t]
- ["Show overriding" ada-show-overriding t]
- ["Show overridden" ada-show-overridden t]
+ ["Goto declaration/body" wisi-goto-spec-body t]
["Goto next statement keyword" forward-sexp t]
["Goto prev statement keyword" backward-sexp t]
+ ["Goto declarative region start" ada-goto-declarative-region-start t]
+ ["Goto containing statement start" wisi-goto-containing-statement-start t]
+ ["Goto subprogram/package start" ada-goto-declaration-start t]
+ ["Goto subprogram/package end" ada-goto-declaration-end t]
+ ["Show parent declarations" wisi-show-declaration-parents t]
+ ["Show references" wisi-show-references t]
+ ["Show overriding" wisi-show-overriding t]
+ ["Show overridden" wisi-show-overridden t]
["-" nil nil]
- ["Align" ada-align t]
- ["Comment/uncomment selection" comment-dwim t]
- ["Fill comment paragraph" ada-fill-comment-paragraph
(ada-in-comment-p)]
- ["Fill comment paragraph justify" (ada-fill-comment-paragraph 'full)
(ada-in-comment-p)]
- ["Fill comment paragraph postfix" (ada-fill-comment-paragraph 'full t)
(ada-in-comment-p)]
- ["Adjust case at point" ada-case-adjust-at-point (not
(use-region-p))]
- ["Adjust case region" ada-case-adjust-region (use-region-p)]
- ["Create full case exception" ada-case-create-exception t]
- ["Create partial case exception" ada-case-create-partial-exception t]
- ["Indent current statement" ada-indent-statement t]
- ["Expand skeleton" ada-expand t]
- ["Make body for subprogram" ada-make-subprogram-body t]
+ ["Align" ada-align t]
+ ["Comment/uncomment selection" comment-dwim t]
+ ["Fill comment paragraph" ada-fill-comment-paragraph
(wisi-in-comment-p)]
+ ["Fill comment paragraph justify" (ada-fill-comment-paragraph 'full)
(wisi-in-comment-p)]
+ ["Fill comment paragraph postfix" (ada-fill-comment-paragraph 'full t)
(wisi-in-comment-p)]
+ ["Adjust case at point" wisi-case-adjust-at-point
(not (use-region-p))]
+ ["Adjust case region" wisi-case-adjust-region
(use-region-p)]
+ ["Create full case exception" wisi-case-create-exception t]
+ ["Create partial case exception" wisi-case-create-partial-exception t]
+ ["Indent current statement" wisi-indent-statement
t]
+ ["Expand skeleton" wisi-skel-expand t]
+ ["Make body for subprogram" ada-make-subprogram-body
t]
))
(defun ada-popup-menu ()
@@ -564,10 +340,10 @@ button was clicked."
(easy-menu-define ada-refactor-menu nil
"Context menu keymap for Ada mode refactor commands."
'("Ada refactor"
- ["Method (Object) => Object.Method" ada-wisi-refactor-1 t]
- ["Object.Method => Method (Object)" ada-wisi-refactor-2 t]
- ["Element (Object, Index) => Object (Index)" ada-wisi-refactor-3 t]
- ["Object (Index) => Element (Object, Index)" ada-wisi-refactor-4 t]
+ ["Method (Object) => Object.Method" ada-refactor-1 t]
+ ["Object.Method => Method (Object)" ada-refactor-2 t]
+ ["Element (Object, Index) => Object (Index)" ada-refactor-3 t]
+ ["Object (Index) => Element (Object, Index)" ada-refactor-4 t]
))
(defun ada-refactor-menu-popup ()
@@ -576,66 +352,6 @@ button was clicked."
(mouse-set-point last-input-event)
(popup-menu ada-refactor-menu))
-(defun ada-indent-newline-indent ()
- "insert a newline, indent the old and new lines."
- (interactive "*")
- ;; point may be in the middle of a word, so insert newline first,
- ;; then go back and indent.
- (insert "\n")
- (unless (and (wisi-partial-parse-p (line-beginning-position)
(line-end-position))
- (save-excursion (progn (forward-char -1)(looking-back
"begin\\|else" (line-beginning-position)))))
- ;; Partial parse may think 'begin' is just the start of a
- ;; statement, when it's actually part of a larger declaration. So
- ;; don't indent 'begin'. Similarly for 'else'; error recovery will
- ;; probably insert 'if then' immediately before it
- (forward-char -1)
- (funcall indent-line-function)
- (forward-char 1))
- (funcall indent-line-function))
-
-(defvar ada-indent-statement nil
- ;; indentation function
- "Function to indent the statement/declaration point is in or after.
-Function is called with no arguments.")
-
-(defun ada-indent-statement ()
- "Indent current statement."
- (interactive)
- (when ada-indent-statement
- (funcall ada-indent-statement)))
-
-(defvar ada-expand nil
- ;; skeleton function
- "Function to call to expand tokens (ie insert skeletons).")
-
-(defun ada-expand ()
- "Expand previous word into a statement skeleton."
- (interactive)
- (when ada-expand
- (funcall ada-expand)))
-
-(defvar ada-next-placeholder nil
- ;; skeleton function
- "Function to call to goto next placeholder.")
-
-(defun ada-next-placeholder ()
- "Goto next placeholder.
-Placeholders are defined by the skeleton backend."
- (interactive)
- (when ada-next-placeholder
- (funcall ada-next-placeholder)))
-
-(defvar ada-prev-placeholder nil
- ;; skeleton function
- "Function to call to goto previous placeholder.")
-
-(defun ada-prev-placeholder ()
- "Goto previous placeholder.
-Placeholders are defined by the skeleton backend."
- (interactive)
- (when ada-prev-placeholder
- (funcall ada-prev-placeholder)))
-
;;;; abbrev, align
(defvar ada-mode-abbrev-table nil
@@ -671,7 +387,7 @@ Placeholders are defined by the skeleton backend."
;; we don't put "when (match-beginning n)" here; missing a match
;; is a bug in the regexp.
(goto-char (or (match-beginning 2) (match-beginning 1)))
- (not (ada-in-string-or-comment-p))))
+ (not (wisi-in-string-or-comment-p))))
(defconst ada-align-region-separate
(eval-when-compile
@@ -686,991 +402,22 @@ Placeholders are defined by the skeleton backend."
"function\\|"
"generic\\|"
"if\\|"
- "is\\|"
- "procedure\\|"
- "private\\|"
- "record\\|"
- "return\\|"
- "type\\|"
- "when"
- "\\)\\_>\\)"))
- "See the variable `align-region-separate' for more information.")
-
-(defun ada-align ()
- "If region is active, apply `align'. If not, attempt to align
-current construct."
- (interactive)
- (if (use-region-p)
- (progn
- (align (region-beginning) (region-end))
- (deactivate-mark))
-
- ;; else see if we are in a construct we know how to align
- (let ((parse-result (syntax-ppss)))
- (cond
- ((ada-in-paramlist-p parse-result)
- (ada-format-paramlist))
-
- ((and
- (ada-in-paren-p parse-result)
- (ada-in-case-expression))
- ;; align '=>'
- (let ((begin (nth 1 parse-result))
- (end (scan-lists (point) 1 1)))
- (align begin end 'entire)))
-
- (t
- (align-current))
- ))))
-
-(defvar ada-in-paramlist-p nil
- ;; Supplied by indentation engine parser
- "Function to return t if point is inside the parameter-list of a subprogram
declaration.
-Function is called with one optional argument; syntax-ppss result.")
-
-(defun ada-in-paramlist-p (&optional parse-result)
- "Return t if point is inside the parameter-list of a subprogram declaration."
- (when ada-in-paramlist-p
- (funcall ada-in-paramlist-p parse-result)))
-
-(defvar ada-refactor-format-paramlist nil) ;; ada-wisi.el
-(declare-function ada-wisi-refactor "ada-wisi.el" (action))
-
-(defun ada-format-paramlist ()
- "Reformat the parameter list point is in."
- (interactive)
- (condition-case nil
- (ada-goto-open-paren)
- (error
- (user-error "Not in parameter list")))
- (funcall indent-line-function); so new list is indented properly
- (when (not (looking-back "^[ \t]*" (line-beginning-position)))
- (delete-horizontal-space)
- (insert " "))
- (ada-wisi-refactor ada-refactor-format-paramlist))
-
-(defvar ada-reset-parser nil
- ;; Supplied by indentation engine parser
- "Function to reset parser, to clear confused state."
- )
-
-(defun ada-reset-parser ()
- "See variable ’ada-reset-parser’."
- (interactive)
- (when ada-reset-parser
- (funcall ada-reset-parser)))
-
-(defvar ada-show-parse-error nil
- ;; Supplied by indentation engine parser
- "Function to show last error reported by indentation parser."
- )
-
-(defun ada-show-parse-error ()
- (interactive)
- (when ada-show-parse-error
- (funcall ada-show-parse-error)))
-
-;;;; auto-casing
-
-(defvar ada-case-full-exceptions '()
- "Alist of words (entities) that have special casing, built from
-project file casing file list full word exceptions. Indexed by
-properly cased word; value is t.")
-
-(defvar ada-case-partial-exceptions '()
- "Alist of partial words that have special casing, built from
-project casing files list partial word exceptions. Indexed by
-properly cased word; value is t.")
-
-(defun ada-case-show-files ()
- "Show current casing files list."
- (interactive)
- (if (ada-prj-get 'casing)
- (progn
- (pop-to-buffer (get-buffer-create "*casing files*"))
- (erase-buffer)
- (dolist (file (ada-prj-get 'casing))
- (insert (format "%s\n" file))))
- (message "no casing files")
- ))
-
-(defun ada-case-save-exceptions (full-exceptions partial-exceptions file-name)
- "Save FULL-EXCEPTIONS, PARTIAL-EXCEPTIONS to the file FILE-NAME."
- (with-temp-file (expand-file-name file-name)
- (mapc (lambda (x) (insert (car x) "\n"))
- (sort (copy-sequence full-exceptions)
- (lambda(a b) (string< (car a) (car b)))))
- (mapc (lambda (x) (insert "*" (car x) "\n"))
- (sort (copy-sequence partial-exceptions)
- (lambda(a b) (string< (car a) (car b)))))
- ))
-
-(defun ada-case-read-exceptions (file-name)
- "Read the content of the casing exception file FILE-NAME.
-Return (cons full-exceptions partial-exceptions)."
- (setq file-name (expand-file-name (substitute-in-file-name file-name)))
- (if (file-readable-p file-name)
- (let (full-exceptions partial-exceptions word)
- (with-temp-buffer
- (insert-file-contents file-name)
- (while (not (eobp))
-
- (setq word (buffer-substring-no-properties
- (point) (save-excursion (skip-syntax-forward "w_")
(point))))
-
- (if (char-equal (string-to-char word) ?*)
- ;; partial word exception
- (progn
- (setq word (substring word 1))
- (unless (assoc-string word partial-exceptions t)
- (push (cons word t) partial-exceptions)))
-
- ;; full word exception
- (unless (assoc-string word full-exceptions t)
- (push (cons word t) full-exceptions)))
-
- (forward-line 1))
- )
- (cons full-exceptions partial-exceptions))
-
- ;; else file not readable; might be a new project with no
- ;; exceptions yet, so just return empty pair
- (message "'%s' is not a readable file." file-name)
- '(nil . nil)
- ))
-
-(defun ada-case-merge-exceptions (result new)
- "Merge NEW exeptions into RESULT.
-An item in both lists has the RESULT value."
- (dolist (item new)
- (unless (assoc-string (car item) result t)
- (push item result)))
- result)
-
-(defun ada-case-merge-all-exceptions (exceptions)
- "Merge EXCEPTIONS into `ada-case-full-exceptions',
`ada-case-partial-exceptions'."
- (setq ada-case-full-exceptions (ada-case-merge-exceptions
ada-case-full-exceptions (car exceptions)))
- (setq ada-case-partial-exceptions (ada-case-merge-exceptions
ada-case-partial-exceptions (cdr exceptions))))
-
-(defun ada-case-read-all-exceptions ()
- "Read case exceptions from all files in project casing files,
-replacing current values of `ada-case-full-exceptions',
`ada-case-partial-exceptions'."
- (interactive)
- (setq ada-case-full-exceptions '()
- ada-case-partial-exceptions '())
-
- (when (ada-prj-get 'casing)
- (dolist (file (ada-prj-get 'casing))
- (ada-case-merge-all-exceptions (ada-case-read-exceptions file))))
- )
-
-(defun ada-case-add-exception (word exceptions)
- "Add case exception WORD to EXCEPTIONS, replacing current entry, if any."
- (if (assoc-string word exceptions t)
- (setcar (assoc-string word exceptions t) word)
- (push (cons word t) exceptions))
- exceptions)
-
-(defun ada-case-create-exception (&optional word file-name partial)
- "Define WORD as an exception for the casing system, save it in FILE-NAME.
-If PARTIAL is non-nil, create a partial word exception. WORD
-defaults to the active region, or the word at point. User is
-prompted to choose a file from project variable casing if it is a
-list."
- (interactive)
- (let ((casing (ada-prj-get 'casing)))
- (setq file-name
- (cond
- (file-name file-name)
-
- ((< 1 (length casing))
- (completing-read "case exception file: " casing
- nil ;; predicate
- t ;; require-match
- nil ;; initial-input
- nil ;; hist
- (car casing) ;; default
- ))
- ((= 1 (length casing))
- (car casing))
-
- (t
- (if ada-prj-current-file
- (error "No exception file specified; set `casing' in project
file.")
- ;; IMPROVEME: could prompt, but then need to write to actual
project file
- ;; (let ((temp
- ;; (read-file-name
- ;; "No exception file specified; adding to
project. file: ")))
- ;; (message "remember to add %s to project file" temp)
- ;; (ada-prj-put 'casing temp)
- ;; temp)
- (error "No exception file specified, and no project active. See
variable `ada-case-exception-file'.")))
- )))
-
- (unless word
- (if (use-region-p)
- (progn
- (setq word (buffer-substring-no-properties (region-beginning)
(region-end)))
- (deactivate-mark))
- (save-excursion
- (let ((syntax (if partial "w" "w_")))
- (skip-syntax-backward syntax)
- (setq word
- (buffer-substring-no-properties
- (point)
- (progn (skip-syntax-forward syntax) (point))
- ))))))
-
- (let* ((exceptions (ada-case-read-exceptions file-name))
- (full-exceptions (car exceptions))
- (partial-exceptions (cdr exceptions)))
-
- (cond
- ((null partial)
- (setq ada-case-full-exceptions (ada-case-add-exception word
ada-case-full-exceptions))
- (setq full-exceptions (ada-case-add-exception word full-exceptions)))
-
- (t
- (setq ada-case-partial-exceptions (ada-case-add-exception word
ada-case-partial-exceptions))
- (setq partial-exceptions (ada-case-add-exception word
partial-exceptions)))
- )
- (ada-case-save-exceptions full-exceptions partial-exceptions file-name)
- (message "created %s case exception '%s' in file '%s'"
- (if partial "partial" "full")
- word
- file-name)
- ))
-
-(defun ada-case-create-partial-exception ()
- "Define active region or word at point as a partial word exception.
-User is prompted to choose a file from project variable casing if it is a
list."
- (interactive)
- (ada-case-create-exception nil nil t))
-
-(defun ada-in-based-numeric-literal-p ()
- "Return t if point is after a prefix of a based numeric literal."
- (looking-back "\\([0-9]+#[0-9a-fA-F_]+\\)" (line-beginning-position)))
-
-(defvar ada-keywords nil
- "List of Ada keywords for current `ada-language-version'.")
-
-(defun ada-after-keyword-p ()
- "Return non-nil if point is after an element of `ada-keywords'."
- (let ((word (buffer-substring-no-properties
- (save-excursion (skip-syntax-backward "w_") (point))
- (point))))
- (member (downcase word) ada-keywords)))
-
-(defun ada-case-keyword (beg end)
- (cl-ecase ada-case-keyword
- (lower-case (downcase-region beg end))
- (upper-case (upcase-region beg end))
- ))
-
-(defun ada-case-identifier (start end force-case-strict)
- (cl-ecase ada-case-identifier
- (mixed-case (ada-mixed-case start end force-case-strict))
- (lower-case (downcase-region start end))
- (upper-case (upcase-region start end))
- ))
-
-(defun ada-mixed-case (start end force-case-strict)
- "Adjust case of region START END to Mixed_Case."
- (let ((done nil)
- next)
- (if (or force-case-strict ada-case-strict)
- (downcase-region start end))
- (goto-char start)
- (while (not done)
- (setq next
- (or
- (save-excursion (when (search-forward "_" end t) (point-marker)))
- (copy-marker (1+ end))))
-
- ;; upcase first char
- (upcase-region (point) (1+ (point)))
-
- (goto-char next)
- (if (< (point) end)
- (setq start (point))
- (setq done t))
- )))
-
-(defun ada-case-adjust-identifier (&optional force-case)
- "Adjust case of the previous word as an identifier.
-Uses `ada-case-identifier', with exceptions defined in
-`ada-case-full-exceptions', `ada-case-partial-exceptions'."
- (interactive)
- (save-excursion
- (let ((end (point-marker))
- (start (progn (skip-syntax-backward "w_") (point)))
- match
- next
- (done nil))
-
- (if (setq match (assoc-string (buffer-substring-no-properties start end)
ada-case-full-exceptions t))
- ;; full word exception
- (progn
- ;; 'save-excursion' puts a marker at 'end'; if we do
- ;; 'delete-region' first, it moves that marker to 'start',
- ;; then 'insert' inserts replacement text after the
- ;; marker, defeating 'save-excursion'. So we do 'insert' first.
- (insert (car match))
- (delete-region (point) end))
-
- ;; else apply ada-case-identifier
- (ada-case-identifier start end force-case)
-
- ;; apply partial-exceptions
- (goto-char start)
- (while (not done)
- (setq next
- (or
- (save-excursion (when (search-forward "_" end t)
(point-marker)))
- (copy-marker (1+ end))))
-
- (when (setq match (assoc-string (buffer-substring-no-properties start
(1- next))
- ada-case-partial-exceptions t))
- ;; see comment above at 'full word exception' for why
- ;; we do insert first.
- (insert (car match))
- (delete-region (point) (1- next)))
-
- (goto-char next)
- (if (< (point) end)
- (setq start (point))
- (setq done t))
- )))))
-
-(defun ada-case-adjust-keyword ()
- "Adjust the case of the previous word as a keyword.
-`word' here is allowed to be underscore-separated (GPR external_as_list)."
- (save-excursion
- (let ((end (point-marker))
- (start (progn (skip-syntax-backward "w_") (point))))
- (ada-case-keyword start end)
- )))
-
-(defun ada-case-adjust (&optional typed-char in-comment)
- "Adjust the case of the word before point.
-When invoked interactively, TYPED-CHAR must be
-`last-command-event', and it must not have been inserted yet.
-If IN-COMMENT is non-nil, adjust case of words in comments and strings as code,
-and treat `ada-case-strict' as t in code.."
- (when (not (bobp))
- (when (save-excursion
- (forward-char -1); back to last character in word
- (and (not (bobp))
- (eq (char-syntax (char-after)) ?w); it can be capitalized
-
- (not (and (eq typed-char ?')
- (eq (char-before (point)) ?'))); character literal
-
- (or in-comment
- (not (ada-in-string-or-comment-p)))
- ;; we sometimes want to capitialize an Ada identifier
- ;; referenced in a comment, via
- ;; ada-case-adjust-at-point.
-
- (not (ada-in-based-numeric-literal-p))
- ;; don't adjust case on hex digits
- ))
-
- ;; The indentation engine may trigger a reparse on
- ;; non-whitespace changes, but we know we don't need to reparse
- ;; for this change (assuming the user has not abused case
- ;; exceptions!).
- (let ((inhibit-modification-hooks t))
- (cond
- ;; Some attributes are also keywords, but captialized as
- ;; attributes. So check for attribute first.
- ((and
- (not in-comment)
- (save-excursion
- (skip-syntax-backward "w_")
- (eq (char-before) ?')))
- (ada-case-adjust-identifier in-comment))
-
- ((and
- (not in-comment)
- (not (eq typed-char ?_))
- (ada-after-keyword-p))
- (ada-case-adjust-keyword))
-
- (t (ada-case-adjust-identifier in-comment))
- ))
- )))
-
-(defun ada-case-adjust-at-point (&optional in-comment)
- "If ’ada-auto-case’ is non-nil, adjust case of word at point, move to end of
word.
-With prefix arg, adjust case as code even if in comment or string;
-otherwise, capitalize words in comments and strings.
-If ’ada-auto-case’ is nil, capitalize current word."
- (interactive "P")
- (cond
- ((or (null ada-auto-case)
- (and (not in-comment)
- (ada-in-string-or-comment-p)))
- (skip-syntax-backward "w_")
- (capitalize-word 1))
-
- (t
- (when
- (and (not (eobp))
- ;; we use '(syntax-after (point))' here, not '(char-syntax
- ;; (char-after))', because the latter does not respect
- ;; ada-syntax-propertize.
- (memq (syntax-class (syntax-after (point))) '(2 3)))
- (skip-syntax-forward "w_"))
- (ada-case-adjust nil in-comment))
- ))
-
-(defun ada-case-adjust-region (begin end)
- "Adjust case of all words in region BEGIN END."
- (interactive "r")
- (narrow-to-region begin end)
- (save-excursion
- (goto-char begin)
- (while (not (eobp))
- (forward-comment (point-max))
- (skip-syntax-forward "^w_")
- (skip-syntax-forward "w_")
- (ada-case-adjust)))
- (widen))
-
-(defun ada-case-adjust-buffer ()
- "Adjust case of current buffer."
- (interactive)
- (ada-case-adjust-region (point-min) (point-max)))
-
-(defun ada-case-adjust-interactive (arg)
- "If `ada-auto-case' is non-nil, adjust the case of the previous word, and
process the character just typed.
-To be bound to keys that should cause auto-casing.
-ARG is the prefix the user entered with \\[universal-argument]."
- (interactive "P")
-
- ;; character typed has not been inserted yet
- (let ((lastk last-command-event)
- (do-adjust nil))
- (cond
- ((null ada-auto-case))
- ((eq ada-auto-case 'not-upper-case)
- (save-excursion
- (let* ((begin (progn (skip-syntax-backward "w_") (point)))
- (end (progn (skip-syntax-forward "w_") (point)))
- (word (buffer-substring-no-properties begin end)))
- (setq do-adjust (not (string-equal word (upcase word)))))))
- (t
- (setq do-adjust t)))
-
- (cond
- ((eq lastk ?\n)
- (when do-adjust
- (ada-case-adjust lastk))
- (funcall ada-lfd-binding))
-
- ((memq lastk '(?\r return))
- (when do-adjust
- (ada-case-adjust lastk))
- (funcall ada-ret-binding))
-
- (t
- (when do-adjust
- (ada-case-adjust lastk))
- (self-insert-command (prefix-numeric-value arg)))
- )))
-
-;;;; project files
-
-;; An Emacs Ada mode project file can specify several things:
-;;
-;; - a compiler-specific project file
-;;
-;; - compiler-specific environment variables
-;;
-;; - other compiler-specific things (see the compiler support elisp code)
-;;
-;; - a list of source directories (in addition to those specified in the
compiler project file)
-;;
-;; - a casing exception file
-;;
-;; All of the data used by Emacs Ada mode functions specified in a
-;; project file is stored in a property list. The property list is
-;; stored in an alist indexed by the project file name, so multiple
-;; project files can be selected without re-parsing them (some
-;; compiler project files can take a long time to parse).
-
-(defvar ada-prj-alist nil
- "Alist holding currently parsed Emacs Ada project files. Indexed by absolute
project file name.")
-
-(defvar ada-prj-current-file nil
- "Current Emacs Ada project file.")
-
-(defvar ada-prj-current-project nil
- "Current Emacs Ada mode project; a plist.")
-
-(defun ada-prj-get (prop &optional plist)
- "Return value of PROP in PLIST.
-Optional PLIST defaults to `ada-prj-current-project'."
- (let ((prj (or plist ada-prj-current-project)))
- (if prj
- (plist-get prj prop)
-
- ;; no project, just use default vars
- ;; must match code in ada-prj-default, except for src_dir.
- (cl-case prop
- (ada_compiler ada-compiler)
- (auto_case ada-auto-case)
- (case_keyword ada-case-keyword)
- (case_identifier ada-case-identifier)
- (case_strict ada-case-strict)
- (casing (if (listp ada-case-exception-file)
- ada-case-exception-file
- (list ada-case-exception-file)))
- (path_sep path-separator)
- (proc_env (cl-copy-list process-environment))
- (src_dir (list (directory-file-name default-directory)))
- (obj_dir (list (directory-file-name default-directory)))
- (xref_tool ada-xref-tool)
- ))))
-
-(defun ada-prj-put (prop val &optional plist)
- "Set value of PROP in PLIST to VAL.
-Optional PLIST defaults to `ada-prj-current-project'."
- (plist-put (or plist ada-prj-current-project) prop val))
-
-(defun ada-require-project-file ()
- (unless ada-prj-current-file
- (error "no Emacs Ada project file specified")))
-
-(defvar ada-prj-default-list nil
- ;; project file parse
- "List of functions to add default project variables. Called
-with one argument; the default project properties
-list. `default-directory' is set to the directory containing the
-project file. Function should add to the properties list and
-return it.")
-
-(defvar ada-prj-default-compiler-alist nil
- ;; project file parse
- "Compiler-specific function to set default project variables.
-Indexed by ada-compiler. Called with one argument; the default
-project properties list. Function should add to the properties
-list and return it.")
-
-(defvar ada-prj-default-xref-alist nil
- ;; project file parse
- "Xref-tool-specific function to set default project variables.
-Indexed by ada-xref-tool. Called with one argument; the default
-project properties list. Function should add to the properties
-list and return it.")
-
-(defun ada-prj-default (&optional src-dir)
- "Return the default project properties list.
-If SRC-DIR is non-nil, use it as the default for src_dir.
-Include properties set via `ada-prj-default-compiler-alist',
-`ada-prj-default-xref-alist'."
-
- (let (project func)
- (setq
- project
- (list
- ;; variable name alphabetical order
- 'ada_compiler ada-compiler
- 'auto_case ada-auto-case
- 'case_keyword ada-case-keyword
- 'case_identifier ada-case-identifier
- 'case_strict ada-case-strict
- 'casing (if (listp ada-case-exception-file)
- ada-case-exception-file
- (list ada-case-exception-file))
- 'path_sep path-separator;; prj variable so users can override it
for their compiler
- 'proc_env (cl-copy-list process-environment)
- 'src_dir (if src-dir (list src-dir) nil)
- 'xref_tool ada-xref-tool
- ))
-
- (cl-dolist (func ada-prj-default-list)
- (setq project (funcall func project)))
-
- (setq func (cdr (assq ada-compiler ada-prj-default-compiler-alist)))
- (when func (setq project (funcall func project)))
- (setq func (cdr (assq ada-xref-tool ada-prj-default-xref-alist)))
- (when func (setq project (funcall func project)))
- project))
-
-(defvar ada-prj-parser-alist
- (mapcar
- (lambda (ext) (cons ext #'ada-prj-parse-file-1))
- ada-prj-file-extensions)
- ;; project file parse
- "Alist of parsers for project files, indexed by file extension.
-Default provides the minimal Ada mode parser; compiler support
-code may add other parsers. Parser is called with two arguments;
-the project file name and the current project property
-list. Parser must modify or add to the property list and return it.")
-
-;; This autoloaded because it is often used in Makefiles, and thus
-;; will be the first ada-mode function executed.
-;;;###autoload
-(defun ada-parse-prj-file (prj-file)
- "Read Emacs Ada or compiler-specific project file PRJ-FILE, set project
properties in `ada-prj-alist'."
- ;; Not called ada-prj-parse-file for Ada mode 4.01 compatibility
- (setq prj-file (expand-file-name prj-file))
-
- (unless (file-readable-p prj-file)
- (error "Project file '%s' is not readable" prj-file))
-
- (run-hooks `ada-prj-parse-hook)
-
- (let* ((default-directory (file-name-directory prj-file))
- (project (ada-prj-default))
- (parser (cdr (assoc (file-name-extension prj-file)
ada-prj-parser-alist))))
-
- (if parser
- ;; parser may reference the "current project", so bind that now.
- (let ((ada-prj-current-project project)
- (ada-prj-current-file prj-file))
- (setq project (funcall parser prj-file project)))
- (error "no project file parser defined for '%s'" prj-file))
-
- ;; Store the project properties
- (if (assoc prj-file ada-prj-alist)
- (setcdr (assoc prj-file ada-prj-alist) project)
- (add-to-list 'ada-prj-alist (cons prj-file project)))
-
- ;; return t for interactive use
- t))
-
-(defun ada-prj-reparse-select-current ()
- "Reparse the current project file, re-select it.
-Useful when the project file has been edited."
- (interactive)
- (ada-parse-prj-file ada-prj-current-file)
- (ada-select-prj-file ada-prj-current-file))
-
-(defun ada-reset-comp-prj ()
- "Reset compilation and project vars affected by a change in compiler version.
-Useful when experimenting with an upgraded compiler."
- (interactive)
- (when (buffer-live-p "*compilation*")
- (with-current-buffer "*compilation*"
- (setq compilation-environment nil)))
- (setq ada-prj-alist nil)
- (setq ada-prj-current-project nil)
- )
-
-(defvar ada-prj-parse-one-compiler nil
- ;; project file parse
- "Compiler-specific function to process one Ada project property.
-Indexed by project variable ada_compiler.
-Called with three arguments; the property name, property value,
-and project properties list. Function should add to or modify the
-properties list and return it, or return nil if the name is not
-recognized.")
-
-(defvar ada-prj-parse-one-xref nil
- ;; project file parse
- "Xref-tool-specific function to process one Ada project property.
-Indexed by project variable xref_tool.
-Called with three arguments; the property name, property value,
-and project properties list. Function should add to or modify the
-properties list and return it, or return nil if the name is not
-recognized.")
-
-(defvar ada-prj-parse-final-compiler nil
- ;; project file parse
- "Alist of compiler-specific functions to finish processing Ada project
properties.
-Indexed by project variable ada_compiler.
-Called with one argument; the project properties list. Function
-should add to or modify the list and return it.")
-
-(defvar ada-prj-parse-final-xref nil
- ;; project file parse
- "Alist of xref-tool-specific functions to finish processing Ada project
properties.
-Indexed by project variable xref_tool.
-Called with one argument; the project properties list. Function
-should add to or modify the list and return it.")
-
-(defun ada-prj-parse-file-1 (prj-file project)
- "Parse the Ada mode project file PRJ-FILE, set project properties in PROJECT.
-Return new value of PROJECT."
- (let (;; fields that are lists or that otherwise require special processing
- casing src_dir obj_dir
- tmp-prj
- (parse-one-compiler (cdr (assoc ada-compiler
ada-prj-parse-one-compiler)))
- (parse-final-compiler (cdr (assoc ada-compiler
ada-prj-parse-final-compiler)))
- (parse-one-xref (cdr (assoc ada-xref-tool ada-prj-parse-one-xref)))
- (parse-final-xref (cdr (assoc ada-xref-tool ada-prj-parse-final-xref))))
-
- (with-current-buffer (find-file-noselect prj-file)
- (goto-char (point-min))
-
- ;; process each line
- (while (not (eobp))
-
- ;; ignore lines that don't have the format "name=value", put
- ;; 'name', 'value' in match-string.
- (when (looking-at "^\\([^=\n]+\\)=\\(.*\\)")
- (cond
- ;; variable name alphabetical order
-
- ((string= (match-string 1) "ada_compiler")
- (let ((comp (intern (match-string 2))))
- (setq project (plist-put project 'ada_compiler comp))
- (setq parse-one-compiler (cdr (assq comp
ada-prj-parse-one-compiler)))
- (setq parse-final-compiler (cdr (assq comp
ada-prj-parse-final-compiler)))))
-
- ((string= (match-string 1) "auto_case")
- (setq project (plist-put project 'auto_case (intern (match-string
2)))))
-
- ((string= (match-string 1) "case_keyword")
- (setq project (plist-put project 'case_keyword (intern
(match-string 2)))))
-
- ((string= (match-string 1) "case_identifier")
- (setq project (plist-put project 'case_identifier (intern
(match-string 2)))))
-
- ((string= (match-string 1) "case_strict")
- (setq project (plist-put project 'case_strict (intern (match-string
2)))))
-
- ((string= (match-string 1) "casing")
- (cl-pushnew (expand-file-name
- (substitute-in-file-name (match-string 2)))
- casing :test #'equal))
-
- ((string= (match-string 1) "el_file")
- (let ((file (expand-file-name (substitute-in-file-name
(match-string 2)))))
- (setq project (plist-put project 'el_file file))
- ;; eval now as well as in select, since it might affect parsing
- (load-file file)))
-
- ((string= (match-string 1) "src_dir")
- (cl-pushnew (file-name-as-directory
- (expand-file-name (match-string 2)))
- src_dir :test #'equal))
-
- ((string= (match-string 1) "obj_dir")
- (cl-pushnew (file-name-as-directory
- (expand-file-name (match-string 2)))
- obj_dir :test #'equal))
-
- ((string= (match-string 1) "xref_tool")
- (let ((xref (intern (match-string 2))))
- (setq project (plist-put project 'xref_tool xref))
- (setq parse-one-xref (cdr (assq xref ada-prj-parse-one-xref)))
- (setq parse-final-xref (cdr (assq xref
ada-prj-parse-final-xref)))))
-
- (t
- (if (or
- (and parse-one-compiler
- (setq tmp-prj (funcall parse-one-compiler (match-string
1) (match-string 2) project)))
- (and parse-one-xref
- (setq tmp-prj (funcall parse-one-xref (match-string 1)
(match-string 2) project))))
-
- (setq project tmp-prj)
-
- ;; Any other field in the file is set as an environment
- ;; variable or a project file variable.
- (if (= ?$ (elt (match-string 1) 0))
- ;; process env var. We don't do expand-file-name
- ;; here because the application may be expecting a
- ;; simple string.
- (let ((process-environment (cl-copy-list (plist-get project
'proc_env))))
- (setenv (substring (match-string 1) 1)
- (substitute-in-file-name (match-string 2)))
- (setq project
- (plist-put project 'proc_env (cl-copy-list
process-environment))))
-
- ;; not recognized; assume it is a user-defined variable like
"comp_opt"
- (setq project (plist-put project (intern (match-string 1))
(match-string 2)))
- )))
- ))
-
- (forward-line 1))
-
- );; done reading file
-
- ;; process accumulated lists
- (if casing (setq project (plist-put project 'casing (reverse casing))))
- (if src_dir (setq project (plist-put project 'src_dir (reverse src_dir))))
- (if obj_dir (setq project (plist-put project 'obj_dir (reverse obj_dir))))
-
- (when parse-final-compiler
- ;; parse-final-compiler may reference the "current project", so
- ;; bind that now, to include the properties set above.
- (let ((ada-prj-current-project project)
- (ada-prj-current-file prj-file))
- (setq project (funcall parse-final-compiler project))))
-
- (when parse-final-xref
- (let ((ada-prj-current-project project)
- (ada-prj-current-file prj-file))
- (setq project (funcall parse-final-xref project))))
-
- project
- ))
-
-(defvar ada-select-prj-compiler nil
- "Alist of functions to call for compiler specific project file selection.
-Indexed by project variable ada_compiler.")
-
-(defvar ada-deselect-prj-compiler nil
- "Alist of functions to call for compiler specific project file deselection.
-Indexed by project variable ada_compiler.")
-
-(defvar ada-select-prj-xref-tool nil
- "Alist of functions to call for xref-tool specific project file selection.
-Indexed by project variable xref_tool.")
-
-(defvar ada-deselect-prj-xref-tool nil
- "Alist of functions to call for xref-tool specific project file deselection.
-Indexed by project variable xref_tool.")
-
-(defun ada-refresh-prj-file ()
- "Reparse, reselect current project file.
-Useful when project has been edited."
- (interactive)
- (let* ((prj-file ada-prj-current-file)
- (parsed (assoc prj-file ada-prj-alist)))
- (setq ada-prj-current-file nil)
- (setq ada-prj-current-project nil)
- (when parsed
- (setq ada-prj-alist (delq parsed ada-prj-alist)))
- (ada-select-prj-file prj-file nil)))
-
-;; This is autoloaded because it is often used in Makefiles, and thus
-;; will be the first ada-mode function executed.
-;;;###autoload
-(defun ada-select-prj-file (prj-file &optional no-force)
- "Select PRJ-FILE as the current project file, parsing it if necessary.
-Deselects the current project first."
- (interactive)
- (setq prj-file (expand-file-name prj-file))
-
- (when (or (not no-force)
- (not (string-equal prj-file ada-prj-current-project)))
- (setq ada-prj-current-project (cdr (assoc prj-file ada-prj-alist)))
-
- (when (null ada-prj-current-project)
- (setq ada-prj-current-file nil)
- (ada-parse-prj-file prj-file)
- (setq ada-prj-current-project (cdr (assoc prj-file ada-prj-alist)))
- (when (null ada-prj-current-project)
- (error "Project file '%s' parse failed." prj-file)))
-
- (let ((func (cdr (assq (ada-prj-get 'ada_compiler)
ada-deselect-prj-compiler))))
- (when func (funcall func)))
-
- (let ((func (cdr (assq (ada-prj-get 'xref_tool)
ada-deselect-prj-xref-tool))))
- (when func (funcall func)))
-
- (setq ada-prj-current-file prj-file)
-
- ;; Project file should fully specify what compilers are used,
- ;; including what compilation filters they need. There may be more
- ;; than just an Ada compiler.
- (setq compilation-error-regexp-alist nil)
- (setq compilation-filter-hook nil)
-
- (when (ada-prj-get 'el_file)
- (load-file (ada-prj-get 'el_file)))
-
- (ada-case-read-all-exceptions)
-
- (setq compilation-search-path (ada-prj-get 'src_dir))
-
- (let ((func (cdr (assq (ada-prj-get 'ada_compiler)
ada-select-prj-compiler))))
- (when func (funcall func)))
-
- (let ((func (cdr (assq (ada-prj-get 'xref_tool)
ada-select-prj-xref-tool))))
- (when func (funcall func)))
-
- ;; return 't', for decent display in message buffer when called
interactively
- t))
-
-(defun ada-deselect-prj (prj)
- "Deselect the project file PRJ, if current."
- ;; For use as ’project-deselect’ (experimental). Duplicates part of
- ;; ’ada-select-prj-file’; should delete that, use this.
- (when (string-equal prj ada-prj-current-file)
- (let ((func (cdr (assq (ada-prj-get 'ada_compiler)
ada-deselect-prj-compiler))))
- (when func (funcall func)))
-
- (let ((func (cdr (assq (ada-prj-get 'xref_tool)
ada-deselect-prj-xref-tool))))
- (when func (funcall func)))
-
- (setq ada-prj-current-project nil)
- ))
-
-(defun ada-create-select-default-prj (&optional directory)
- "Create a default project with src_dir set to DIRECTORY (default current
directory), select it."
- (let* ((dir (or directory default-directory))
- (prj-file (expand-file-name "default_.adp" dir))
- (project (ada-prj-default dir)))
-
- (if (assoc prj-file ada-prj-alist)
- (setcdr (assoc prj-file ada-prj-alist) project)
- (add-to-list 'ada-prj-alist (cons prj-file project)))
-
- (ada-select-prj-file prj-file)
- ))
-
-(defun ada-prj-select ()
- "Select the current project file from the list of currently available
project files."
- (interactive)
- (ada-select-prj-file (completing-read "project: " ada-prj-alist nil t))
- )
-
-(defun ada-prj-delete ()
- "Delete a project file from the list of currently available project files."
- (interactive)
- (let* ((prj-file (completing-read "project: " ada-prj-alist nil t))
- (prj-entry (assoc prj-file ada-prj-alist)))
- (setq ada-prj-alist (delete prj-entry ada-prj-alist))
- ))
-
-(defun ada-prj-show ()
- "Show current Emacs Ada mode project file."
- (interactive)
- (message "current Emacs Ada mode project file: %s" ada-prj-current-file))
-
-(defvar ada-prj-show-prj-path nil
- ;; Supplied by compiler
- "Function to show project file search path used by compiler (and possibly
xref tool)."
- )
-
-(defun ada-prj-show-prj-path ()
- (interactive)
- (when ada-prj-show-prj-path
- (funcall ada-prj-show-prj-path)))
-
-(defun ada-prj-show-src-path ()
- "Show the project source file search path."
- (interactive)
- (if compilation-search-path
- (progn
- (pop-to-buffer (get-buffer-create "*Ada project source file search
path*"))
- (erase-buffer)
- (dolist (file compilation-search-path)
- (insert (format "%s\n" file))))
- (message "no project source file search path set")
- ))
-
-(defvar ada-show-xref-tool-buffer nil
- ;; Supplied by xref tool
- "Function to show process buffer used by xref tool."
- )
-
-(defun ada-show-xref-tool-buffer ()
- (interactive)
- (when ada-show-xref-tool-buffer
- (funcall ada-show-xref-tool-buffer)))
+ "is\\|"
+ "procedure\\|"
+ "private\\|"
+ "record\\|"
+ "return\\|"
+ "type\\|"
+ "when"
+ "\\)\\_>\\)"))
+ "See the variable `align-region-separate' for more information.")
;;;; syntax properties
(defvar ada-mode-syntax-table
(let ((table (make-syntax-table)))
;; (info "(elisp)Syntax Class Table" "*info syntax class table*")
+ ;; (info "(elisp) Syntax Flags") for comment start/end
;; make-syntax-table sets all alphanumeric to w, etc; so we only
;; have to add ada-specific things.
@@ -1686,23 +433,22 @@ Deselects the current project first."
(modify-syntax-entry ?& "." table)
(modify-syntax-entry ?* "." table)
(modify-syntax-entry ?+ "." table)
- (modify-syntax-entry ?- "." table); operator; see ada-syntax-propertize
for double hyphen as comment
+ (modify-syntax-entry ?- ". 124" table); operator, double hyphen as comment
(modify-syntax-entry ?. "." table)
(modify-syntax-entry ?/ "." table)
(modify-syntax-entry ?: "." table)
(modify-syntax-entry ?< "." table)
(modify-syntax-entry ?= "." table)
(modify-syntax-entry ?> "." table)
+ (modify-syntax-entry ?@ "." table)
(modify-syntax-entry ?\' "." table); attribute; see ada-syntax-propertize
for character literal
(modify-syntax-entry ?\; "." table)
(modify-syntax-entry ?\\ "." table); default is escape; not correct for
Ada strings
(modify-syntax-entry ?\| "." table)
;; \f and \n end a comment.
- ;; comment start set in ada-syntax-propertize.
- ;; flag ’s’ experimental; end unterminated string at newline.
- (modify-syntax-entry ?\f "> s" table)
- (modify-syntax-entry ?\n "> s" table)
+ (modify-syntax-entry ?\f ">" table)
+ (modify-syntax-entry ?\n ">" table)
(modify-syntax-entry ?_ "_" table); symbol constituents, not word.
@@ -1719,13 +465,6 @@ Deselects the current project first."
)
"Syntax table to be used for editing Ada source code.")
-(defvar ada-syntax-propertize-hook nil
- ;; provided by preprocessor, lumped with xref-tool
- "Hook run from `ada-syntax-propertize'.
-Called by `syntax-propertize', which is called by font-lock in
-`after-change-functions'. Therefore, care must be taken to avoid
-race conditions with the grammar parser.")
-
(defun ada-syntax-propertize (start end)
"For `syntax-propertize-function'.
Assign `syntax-table' properties in region START .. END.
@@ -1742,7 +481,6 @@ Runs `ada-syntax-propertize-hook'."
(concat
"[^a-zA-Z0-9)]\\('\\)[^'\n]\\('\\)"; 1, 2: character literal,
not attribute
"\\|[^a-zA-Z0-9)]\\('''\\)"; 3: character literal '''
- "\\|\\(--\\)"; 4: comment start
)
end t)
;; syntax-propertize-extend-region-functions is set to
@@ -1760,49 +498,10 @@ Runs `ada-syntax-propertize-hook'."
(match-beginning 3) (1+ (match-beginning 3)) 'syntax-table '(7 . ?'))
(put-text-property
(1- (match-end 3)) (match-end 3) 'syntax-table '(7 . ?')))
- ((match-beginning 4)
- (put-text-property
- (match-beginning 4) (match-end 4) 'syntax-table '(11 . nil)))
)))
(run-hook-with-args 'ada-syntax-propertize-hook start end))
)
-(defun ada-in-comment-p (&optional parse-result)
- "Return t if inside a comment.
-If PARSE-RESULT is non-nil, use it instead of calling `syntax-ppss'."
- (nth 4 (or parse-result (syntax-ppss))))
-
-(defun ada-in-string-p (&optional parse-result)
- "Return t if point is inside a string.
-If PARSE-RESULT is non-nil, use it instead of calling `syntax-ppss'."
- (nth 3 (or parse-result (syntax-ppss))))
-
-(defun ada-in-string-or-comment-p (&optional parse-result)
- "Return t if inside a comment or string.
-If PARSE-RESULT is non-nil, use it instead of calling `syntax-ppss'."
- (setq parse-result (or parse-result (syntax-ppss)))
- (or (ada-in-string-p parse-result) (ada-in-comment-p parse-result)))
-
-(defun ada-in-paren-p (&optional parse-result)
- "Return t if point is inside a pair of parentheses.
-If PARSE-RESULT is non-nil, use it instead of calling `syntax-ppss'."
- (> (nth 0 (or parse-result (syntax-ppss))) 0))
-
-(defun ada-pos-in-paren-p (pos)
- "Return t if POS is inside a pair of parentheses."
- (save-excursion
- (> (nth 0 (syntax-ppss pos)) 0)))
-
-(defun ada-same-paren-depth-p (pos1 pos2)
- "Return t if POS1 is at same parentheses depth as POS2."
- (= (nth 0 (syntax-ppss pos1)) (nth 0 (syntax-ppss pos2))))
-
-(defun ada-goto-open-paren (&optional offset parse-result)
- "Move point to innermost opening paren surrounding current point, plus
OFFSET.
-Throw error if not in paren. If PARSE-RESULT is non-nil, use it
-instead of calling `syntax-ppss'."
- (goto-char (+ (or offset 0) (nth 1 (or parse-result (syntax-ppss))))))
-
;;;; navigation within and between files
(defvar ada-body-suffixes '(".adb")
@@ -1819,34 +518,10 @@ The extensions should include a `.' if needed.")
"Alist used by `find-file' to find the name of the other package.
See `ff-other-file-alist'.")
-(defconst ada-name-regexp
- "\\(\\(?:\\sw\\|[_.]\\)+\\)")
-
(defconst ada-parent-name-regexp
"\\([a-zA-Z0-9_\\.]+\\)\\.[a-zA-Z0-9_]+"
"Regexp for extracting the parent name from fully-qualified name.")
-(defvar ada-file-name-from-ada-name nil
- ;; determined by ada-xref-tool, set by *-select-prj
- "Function called with one parameter ADA-NAME, which is a library
-unit name; it should return the filename in which ADA-NAME is
-found.")
-
-(defun ada-file-name-from-ada-name (ada-name)
- "Return the filename in which ADA-NAME is found."
- (ada-require-project-file)
- (funcall ada-file-name-from-ada-name ada-name))
-
-(defvar ada-ada-name-from-file-name nil
- ;; supplied by compiler
- "Function called with one parameter FILE-NAME, which is a library
-unit name; it should return the Ada name that should be found in FILE-NAME.")
-
-(defun ada-ada-name-from-file-name (file-name)
- "Return the ada-name that should be found in FILE-NAME."
- (ada-require-project-file)
- (funcall ada-ada-name-from-file-name file-name))
-
(defun ada-ff-special-extract-parent ()
(setq ff-function-name (match-string 1))
(file-name-nondirectory
@@ -1889,62 +564,91 @@ unit name; it should return the Ada name that should be
found in FILE-NAME.")
'ada-ff-special-with)
)))
-(defvar ada-which-function nil
- ;; supplied by indentation engine
- ;;
- ;; This is run from ff-pre-load-hook, so ff-function-name may have
- ;; been set by ff-treat-special; don't reset it.
- "Function called with one parameter (INCLUDE-TYPE); it should
-return the name of the package, protected type, subprogram,
-entry, or task type whose definition/declaration point is in, or
-for declarations that don't have declarative regions, just after;
-or nil.
-
-If INCLUDE-TYPE is non-nil, include type names.
-
-In addition, if `ff-function-name' is non-nil, store in
-`ff-function-name' a regexp that will find the function in the
-other file.")
+(defun ada-which-function-1 (keyword add-body)
+ "Used in `ada-which-function'."
+ (let* ((result (wisi-next-name)))
+
+ ;; See comment in ada-which-function on why we don't
+ ;; overwrite ff-function-name.
+ (when (not ff-function-name)
+ (setq ff-function-name
+ (concat
+ keyword
+ (when add-body "\\s-+body")
+ "\\s-+"
+ result
+ "\\_>")))
+ result))
(defun ada-which-function (&optional include-type)
- "See `ada-which-function' variable."
- (when ada-which-function
- (funcall ada-which-function include-type)))
-
-(defvar ada-on-context-clause nil
- ;; supplied by indentation engine
- "Function called with no parameters; it should return non-nil
- if point is on a context clause.")
-
-(defun ada-on-context-clause ()
- "See `ada-on-context-clause' variable."
- (interactive)
- (when ada-on-context-clause
- (funcall ada-on-context-clause)))
-
-(defvar ada-in-case-expression nil
- ;; supplied by indentation engine
- "Function called with no parameters; it should return non-nil
- if point is in a case expression.")
-
-(defun ada-in-case-expression ()
- "See `ada-in-case-expression' variable."
- (interactive)
- (when ada-in-case-expression
- (funcall ada-in-case-expression)))
-
-(defvar ada-goto-subunit-name nil
- ;; supplied by indentation engine
- "Function called with no parameters; if the current buffer
- contains a subunit, move point to the subunit name (for
- `ada-goto-declaration'), return t; otherwise leave point alone,
- return nil.")
-
-(defun ada-goto-subunit-name ()
- "See `ada-goto-subunit-name' variable."
- (interactive)
- (when ada-goto-subunit-name
- (funcall ada-goto-subunit-name)))
+ "Return name of subprogram/task/package containing point.
+Also sets ff-function-name for ff-pre-load-hook."
+ ;; Fail gracefully and silently, since this could be called from
+ ;; which-function-mode.
+ (let ((parse-begin (max (point-min) (- (point) (/ ada-which-func-parse-size
2))))
+ (parse-end (min (point-max) (+ (point) (/ ada-which-func-parse-size
2)))))
+ (save-excursion
+ (condition-case nil
+ (progn
+ (wisi-validate-cache parse-begin parse-end nil 'navigate)
+ (when (wisi-cache-covers-region parse-begin parse-end 'navigate)
+ (let ((result nil)
+ (cache (ada-goto-declaration-start-1 include-type)))
+ (if (null cache)
+ ;; bob or failed parse
+ (setq result "")
+
+ (when (memq (wisi-cache-nonterm cache)
+ '(generic_package_declaration
generic_subprogram_declaration))
+ ;; name is after next statement keyword
+ (setq cache (wisi-next-statement-cache cache)))
+
+ ;; add or delete 'body' as needed
+ (cl-ecase (wisi-cache-nonterm cache)
+ ((entry_body entry_declaration)
+ (setq result (ada-which-function-1 "entry" nil)))
+
+ (full_type_declaration
+ (setq result (ada-which-function-1 "type" nil)))
+
+ (package_body
+ (setq result (ada-which-function-1 "package" nil)))
+
+ ((package_declaration
+ package_specification) ;; after 'generic'
+ (setq result (ada-which-function-1 "package" t)))
+
+ (protected_body
+ (setq result (ada-which-function-1 "protected" nil)))
+
+ ((protected_type_declaration single_protected_declaration)
+ (setq result (ada-which-function-1 "protected" t)))
+
+ ((abstract_subprogram_declaration
+ expression_function_declaration
+ subprogram_declaration
+ subprogram_renaming_declaration
+ generic_subprogram_declaration ;; after 'generic'
+ null_procedure_declaration)
+ (setq result (ada-which-function-1
+ (progn (search-forward-regexp
"function\\|procedure")(match-string 0))
+ nil))) ;; no 'body' keyword in subprogram
bodies
+
+ (subprogram_body
+ (setq result (ada-which-function-1
+ (progn (search-forward-regexp
"function\\|procedure")(match-string 0))
+ nil)))
+
+ ((single_task_declaration task_type_declaration)
+ (setq result (ada-which-function-1 "task" t)))
+
+
+ (task_body
+ (setq result (ada-which-function-1 "task" nil)))
+ ))
+ result)))
+ (error "")))
+ ))
(defun ada-add-log-current-function ()
"For `add-log-current-defun-function'."
@@ -1956,6 +660,39 @@ other file.")
(back-to-indentation)
(ada-which-function t)))
+(defun ada-on-context-clause ()
+ "Return non-nil if point is on a context clause."
+ (interactive)
+ (let (cache)
+ (save-excursion
+ ;; Don't require parse of large file just for ada-find-other-file
+ (and (< (point-max) wisi-size-threshold)
+ (setq cache (wisi-goto-statement-start))
+ (memq (wisi-cache-nonterm cache) '(use_clause with_clause))
+ ))))
+
+(defun ada-goto-subunit-name ()
+ "Return non-nil if the current buffer contains a subunit.
+Also move point to the subunit name. If no subunit, leave point
+alone, return nil."
+ (interactive)
+ (wisi-validate-cache (point-min) (point-max) t 'navigate)
+
+ (let (cache
+ (name-pos nil))
+ (save-excursion
+ ;; move to top declaration
+ (goto-char (point-min))
+ (setq cache (or (wisi-get-cache (point))
+ (wisi-forward-cache)))
+
+ (when (eq (wisi-cache-nonterm cache) 'subunit)
+ (setq name-pos (car (wisi-next-name-region))))
+ )
+ (when name-pos
+ (goto-char name-pos))
+ ))
+
(defun ada-set-point-accordingly ()
"Move to the string specified in `ff-function-name', which may be a regexp,
previously set by a file navigation command."
@@ -1972,7 +709,7 @@ previously set by a file navigation command."
(setq found (match-beginning 0))
;; not in remainder of buffer
(setq done t))
- (if (ada-in-string-or-comment-p)
+ (if (wisi-in-string-or-comment-p)
(setq found nil)
(setq done t)))
(when found
@@ -1981,30 +718,6 @@ previously set by a file navigation command."
(back-to-indentation))
(setq ff-function-name nil))))
-(defun ada-check-current-project (file-name)
- "Throw error if FILE-NAME (must be absolute) is not found in
-the current project source directories, or if no project has been
-set."
- (when (null (car compilation-search-path))
- (error "no file search path defined; set project file?"))
-
- ;; file-truename handles symbolic links
- (let* ((visited-file (file-truename file-name))
- (found-file (locate-file (file-name-nondirectory visited-file)
- compilation-search-path)))
- (unless found-file
- (error "current file not part of current project; wrong project?"))
-
- (setq found-file (file-truename found-file))
-
- ;; (nth 10 (file-attributes ...)) is the inode; required when hard
- ;; links are present.
- (let* ((visited-file-inode (nth 10 (file-attributes visited-file)))
- (found-file-inode (nth 10 (file-attributes found-file))))
- (unless (equal visited-file-inode found-file-inode)
- (error "%s (opened) and %s (found in project) are two different files"
- file-name found-file)))))
-
(defun ada-find-other-file ()
"Move to the corresponding declaration in another file.
@@ -2035,7 +748,7 @@ set."
;; information
(interactive)
- (ada-check-current-project (buffer-file-name))
+ (wisi-check-current-project (buffer-file-name) #'ada-prj-default)
;; clear ff-function-name, so either ff-special-constructs or
;; ada-which-function will set it.
@@ -2053,312 +766,13 @@ set."
((and (not (ada-on-context-clause))
(ada-goto-subunit-name))
- (ada-goto-declaration))
+ (call-interactively 'wisi-goto-spec/body))
(t
(ff-find-other-file)))
)
-(defun ada-find-file (filename)
- ;; we assume compliation-search-path is set, either by an
- ;; ada-mode project, or by some other means.
- (interactive (list (completing-read "File: "
- (apply-partially
- 'locate-file-completion-table
- compilation-search-path nil))))
- (find-file (locate-file filename compilation-search-path))
- )
-
-(defvar ada-operator-re
-
"\\+\\|-\\|/\\|\\*\\*\\|\\*\\|=\\|&\\|\\_<\\(abs\\|mod\\|rem\\|and\\|not\\|or\\|xor\\)\\_>\\|<=\\|<\\|>=\\|>"
- "Regexp matching Ada operator_symbol.")
-
-(defun ada-identifier-at-point ()
- "Return the identifier around point, move point to start of
-identifier. May be an Ada identifier or operator."
-
- (when (ada-in-comment-p)
- (error "Inside comment"))
-
- ;; Handle adjacent operator/identifer like:
- ;; test/ada_mode-slices.adb
- ;; D1, D2 : Day := +Sun;
-
- ;; Move to the beginning of the identifier or operator
- (if (looking-at "[a-zA-Z0-9_]")
- ;; In an identifier
- (skip-chars-backward "a-zA-Z0-9_")
- ;; In an operator
- (skip-chars-backward "+\\-\\*/&<>="))
-
- ;; Just in front of, or inside, a string => we could have an
- ;; operator function declaration.
- (cond
- ((ada-in-string-p)
- (cond
-
- ((and (= (char-before) ?\")
- (progn
- (forward-char -1)
- (looking-at (concat "\"\\(" ada-operator-re "\\)\""))))
- (concat "\"" (match-string-no-properties 1) "\""))
-
- (t
- (error "Inside string or character constant"))
- ))
-
- ((and (= (char-after) ?\")
- (looking-at (concat "\"\\(" ada-operator-re "\\)\"")))
- (concat "\"" (match-string-no-properties 1) "\""))
-
- ((looking-at ada-operator-re)
- ;; Return quoted operator, as this is what the back end expects.
- (concat "\"" (match-string-no-properties 0) "\""))
-
- ((looking-at "[a-zA-Z0-9_]+")
- (match-string-no-properties 0))
-
- (t
- (error "No identifier around"))
- ))
-
-;; IMPROVEME (for emacs >= 25): use find-tag-marker-ring, ring-insert,
pop-tag-mark (see xref.el)
-(defvar ada-goto-pos-ring '()
- "List of positions selected by navigation functions. Used
-to go back to these positions.")
-
-(defconst ada-goto-pos-ring-max 16
- "Number of positions kept in the list `ada-goto-pos-ring'.")
-
-(defun ada-goto-push-pos ()
- "Push current filename, position on `ada-goto-pos-ring'. See
`ada-goto-previous-pos'."
- (setq ada-goto-pos-ring (cons (list (point) (buffer-file-name))
ada-goto-pos-ring))
- (if (> (length ada-goto-pos-ring) ada-goto-pos-ring-max)
- (setcdr (nthcdr (1- ada-goto-pos-ring-max) ada-goto-pos-ring) nil)))
-
-(defun ada-goto-previous-pos ()
- "Go to the first position in `ada-goto-pos-ring', pop `ada-goto-pos-ring'."
- (interactive)
- (when ada-goto-pos-ring
- (let ((pos (pop ada-goto-pos-ring)))
- (find-file (cadr pos))
- (goto-char (car pos)))))
-
-(defun ada-goto-source (file line column)
- "Find and select FILE, at LINE and COLUMN.
-FILE may be absolute, or on `compilation-search-path'.
-LINE, COLUMN are Emacs origin."
- (let ((file-1
- (if (file-name-absolute-p file) file
- (ff-get-file-name compilation-search-path file))))
- (if file-1
- (setq file file-1)
- (error "File %s not found; installed library, or set project?" file))
- )
-
- (ada-goto-push-pos)
-
- (let ((buffer (get-file-buffer file)))
- (cond
- ((bufferp buffer)
- ;; use pop-to-buffer, so package other-frame-window works.
- (pop-to-buffer buffer (list #'display-buffer-same-window)))
-
- ((file-exists-p file)
- (find-file file))
-
- (t
- (error "'%s' not found" file))))
-
- ;; move the cursor to the correct position
- (push-mark nil t)
- (goto-char (point-min))
- (forward-line (1- line))
- (forward-char column)
- )
-
-(defvar ada-xref-refresh-function nil
- ;; determined by xref_tool, set by *-select-prj-xref
- "Function that refreshes cross reference information cache.")
-
-(defun ada-xref-refresh (delete-files)
- "Refresh cross reference information cache, if any.
-With non-nil prefix arg, delete cross reference files, which may
-be needed when a compiler is upgraded, or some configuration is
-changed."
- (interactive "P")
-
- (when (null ada-xref-refresh-function)
- (error "no cross reference information available"))
-
- (funcall ada-xref-refresh-function delete-files)
- )
-
-(defvar ada-xref-other-function nil
- ;; determined by xref_tool, set by *-select-prj-xref
- "Function that returns cross reference information.
-Function is called with four arguments:
-- an Ada identifier or operator_symbol
-- filename containing the identifier (full path)
-- line number containing the identifier
-- Emacs column of the start of the identifier
-Point is on the start of the identifier.
-Returns a list (FILE LINE COLUMN) giving the corresponding location.
-FILE may be absolute, or on `compilation-search-path'. If point is
-at the specification, the corresponding location is the body, and vice
-versa.")
-
-(defun ada-goto-declaration ()
- "Move to the declaration or body of the identifier around point.
-If at the declaration, go to the body, and vice versa."
- (interactive)
- (ada-check-current-project (buffer-file-name))
-
- (when (null ada-xref-other-function)
- (error "no cross reference information available"))
-
- (let ((target
- (funcall ada-xref-other-function
- (ada-identifier-at-point)
- (buffer-file-name)
- (line-number-at-pos)
- (current-column)
- )))
-
- (ada-goto-source (nth 0 target)
- (nth 1 target)
- (nth 2 target))
- ))
-
-(defvar ada-xref-parent-function nil
- ;; determined by xref_tool, set by *-select-prj-xref
- "Function that returns cross reference information.
-Function is called with four arguments:
-- an Ada identifier or operator_symbol
-- filename containing the identifier
-- line number containing the identifier
-- Emacs column of the start of the identifier
-Displays a buffer in compilation-mode giving locations of the parent type
declarations.")
-
-(defun ada-show-declaration-parents ()
- "Display the locations of the parent type declarations of the type
identifier around point."
- (interactive)
- (ada-check-current-project (buffer-file-name))
-
- (when (null ada-xref-parent-function)
- (error "no cross reference information available"))
-
- (funcall ada-xref-parent-function
- (ada-identifier-at-point)
- (file-name-nondirectory (buffer-file-name))
- (line-number-at-pos)
- (current-column))
- )
-
-(defvar ada-xref-all-function nil
- ;; determined by xref_tool, set by *-select-prj-xref
- "Function that displays cross reference information.
-Called with four arguments:
-- an Ada identifier or operator_symbol
-- filename containing the identifier
-- line number containing the identifier
-- Emacs column of the start of the identifier
-- local-only; if t, show references in current file only
-- append; if t, keep previous output in result buffer
-Displays a buffer in compilation-mode giving locations where the
-identifier is declared or referenced.")
-
-(defun ada-show-references (&optional append)
- "Show all references of identifier at point.
-With prefix, keep previous references in output buffer."
- (interactive "P")
- (ada-check-current-project (buffer-file-name))
-
- (when (null ada-xref-all-function)
- (error "no cross reference information available"))
-
- (funcall ada-xref-all-function
- (ada-identifier-at-point)
- (file-name-nondirectory (buffer-file-name))
- (line-number-at-pos)
- (current-column)
- nil ;; local-only
- append)
- )
-
-(defun ada-show-local-references (&optional append)
- "Show all references of identifier at point.
-With prefix, keep previous references in output buffer."
- (interactive "P")
- (ada-check-current-project (buffer-file-name))
-
- (when (null ada-xref-all-function)
- (error "no cross reference information available"))
-
- (funcall ada-xref-all-function
- (ada-identifier-at-point)
- (file-name-nondirectory (buffer-file-name))
- (line-number-at-pos)
- (current-column)
- t ;; local-only
- append)
- )
-
-(defvar ada-xref-overriding-function nil
- ;; determined by ada-xref-tool, set by *-select-prj
- "Function that displays cross reference information for overriding
subprograms.
-Called with four arguments:
-- an Ada identifier or operator_symbol
-- filename containing the identifier
-- line number containing the identifier
-- Emacs column of the start of the identifier
-Displays a buffer in compilation-mode giving locations of the overriding
declarations.")
-
-(defun ada-show-overriding ()
- "Show all overridings of identifier at point."
- (interactive)
- (ada-check-current-project (buffer-file-name))
-
- (when (null ada-xref-overriding-function)
- (error "no cross reference information available"))
-
- (funcall ada-xref-overriding-function
- (ada-identifier-at-point)
- (file-name-nondirectory (buffer-file-name))
- (line-number-at-pos)
- (current-column))
- )
-
-(defvar ada-xref-overridden-function nil
- ;; determined by ada-xref-tool, set by *-select-prj
- "Function that displays cross reference information for overridden
subprogram.
-Called with four arguments:
-- an Ada identifier or operator_symbol
-- filename containing the identifier
-- line number containing the identifier
-- Emacs column of the start of the identifier
-Returns a list (FILE LINE COLUMN) giving the corresponding location.
-FILE may be absolute, or on `compilation-search-path'.")
-
-(defun ada-show-overridden ()
- "Show the overridden declaration of identifier at point."
- (interactive)
- (ada-check-current-project (buffer-file-name))
-
- (when (null ada-xref-overridden-function)
- (error "'show overridden' not supported, or no cross reference information
available"))
-
- (let ((target
- (funcall ada-xref-overridden-function
- (ada-identifier-at-point)
- (file-name-nondirectory (buffer-file-name))
- (line-number-at-pos)
- (current-column))))
-
- (ada-goto-source (nth 0 target)
- (nth 1 target)
- (nth 2 target))
- ))
+;;;; Misc
;; This is autoloaded because it may be used in ~/.emacs
;;;###autoload
@@ -2424,124 +838,89 @@ compiler-specific compilation filters."
(pop-to-buffer start-buffer nil t);; for windowing history
)
(when item
- (ada-goto-source
+ (wisi-goto-source
file
(nth 1 item); line
(nth 2 item); column
))
))
-(defvar ada-goto-declaration-start nil
- ;; Supplied by indentation engine.
- ;;
- "For `beginning-of-defun-function'. Function to move point to
-start of the generic, package, protected, subprogram, or task
-declaration point is currently in or just after. Called with no
-parameters.")
+(defun ada-goto-declaration-start-1 (include-type)
+ "Subroutine of `ada-goto-declaration-start'."
+ (let ((start (point))
+ (cache (wisi-get-cache (point)))
+ (done nil))
+ (unless cache
+ (setq cache (wisi-backward-cache)))
+ ;; cache is null at bob
+ (while (not done)
+ (if cache
+ (progn
+ (setq done
+ (cl-case (wisi-cache-nonterm cache)
+ ((entry_body entry_declaration)
+ (eq (wisi-cache-token cache) 'ENTRY))
+
+ (full_type_declaration
+ (when include-type
+ (eq (wisi-cache-token cache) 'TYPE)))
+
+ ((generic_package_declaration
generic_subprogram_declaration)
+ (eq (wisi-cache-token cache) 'GENERIC))
+
+ ((package_body package_declaration)
+ (eq (wisi-cache-token cache) 'PACKAGE))
+
+ ((protected_body protected_type_declaration
single_protected_declaration)
+ (eq (wisi-cache-token cache) 'PROTECTED))
+
+ ((abstract_subprogram_declaration
+ expression_function_declaration
+ subprogram_body
+ subprogram_declaration
+ subprogram_renaming_declaration
+ null_procedure_declaration)
+ (memq (wisi-cache-token cache) '(NOT OVERRIDING FUNCTION
PROCEDURE)))
+
+ ((single_task_declaration task_body task_type_declaration)
+ (eq (wisi-cache-token cache) 'TASK))
+
+ ))
+ (unless (< start (wisi-cache-end cache))
+ ;; found declaration does not include start; find containing one.
+ (setq done nil))
+ (unless done
+ (setq cache (wisi-goto-containing cache nil))))
+ (setq done t))
+ )
+ cache))
-(defun ada-goto-declaration-start ()
- "Call `ada-goto-declaration-start'."
+(defun ada-goto-declaration-start (&optional include-type)
+ "Move point to start of the generic, package, protected,
+subprogram, or task declaration point is currently in or just
+after. For `beginning-of-defun-function'."
(interactive)
- (when ada-goto-declaration-start
- (funcall ada-goto-declaration-start)))
-
-(defvar ada-goto-declaration-end nil
- ;; supplied by indentation engine
- "For `end-of-defun-function'. Function to move point to end of
-current declaration.")
+ (wisi-validate-cache (point-min) (point-max) t 'navigate)
+ (ada-goto-declaration-start-1 include-type))
(defun ada-goto-declaration-end ()
- "See `ada-goto-declaration-end' variable."
+ "Move point to end of current declaration.
+For `end-of-defun-function'."
(interactive)
- (when ada-goto-declaration-end
- (funcall ada-goto-declaration-end)))
-
-(defvar ada-goto-declarative-region-start nil
- ;; Supplied by indentation engine
- "Function to move point to start of the declarative region of
-the subprogram, package, task, or declare block point
-is currently in. Called with no parameters.")
-
-(defun ada-goto-declarative-region-start ()
- "Call `ada-goto-declarative-region-start'."
- (interactive)
- (when ada-goto-declarative-region-start
- (funcall ada-goto-declarative-region-start)))
-
-(defvar ada-goto-end nil
- ;; Supplied by indentation engine
- "Function to move point to end of the declaration or statement point is in
or before.
-Called with no parameters.")
-
-(defun ada-goto-end ()
- "Call `ada-goto-end'."
- (when ada-goto-end
- (funcall ada-goto-end)))
-
-;;;; code creation
-
-(defvar ada-make-subprogram-body nil
- ;; Supplied by indentation engine
- "Function to convert subprogram specification after point into a subprogram
body stub.
-Called with no args, point at declaration start. Leave point in
-subprogram body, for user to add code.")
-
-(defun ada-make-subprogram-body ()
- "If point is in or after a subprogram specification, convert it
-into a subprogram body stub, by calling `ada-make-subprogram-body'."
- (interactive)
- (wisi-goto-statement-start)
- (if ada-make-subprogram-body
- (funcall ada-make-subprogram-body)
- (error "`ada-make-subprogram-body' not set")))
-
-(defvar ada-make-package-body nil
- ;; Supplied by xref tool
- "Function to create a package body from a package spec.
-Called with one argument; the absolute path to the body
-file. Current buffer is the package spec. Should create the
-package body file, containing skeleton code that will compile.")
-
-(defun ada-make-package-body (body-file-name)
- ;; no error if not set; let ada-skel do its thing.
- (when ada-make-package-body
- (funcall ada-make-package-body body-file-name)))
-
-(defun ada-ff-create-body ()
- ;; no error if not set; let ada-skel do its thing.
- (when ada-make-package-body
- ;; ff-find-other-file calls us with point in an empty buffer for
- ;; the body file; ada-make-package-body expects to be in the
- ;; spec. So go back to the spec, and delete the body buffer so it
- ;; does not get written to disk.
- (let ((body-buffer (current-buffer))
- (body-file-name (buffer-file-name)))
-
- (set-buffer-modified-p nil);; may have a skeleton; allow silent delete
-
- (ff-find-the-other-file);; back to spec
-
- (kill-buffer body-buffer)
-
- (ada-make-package-body body-file-name)
-
- ;; back to the new body file, read in from the disk.
- (ff-find-the-other-file)
- (revert-buffer t t))
- ))
+ ;; First goto-declaration-start, so we get the right end, not just
+ ;; the current statement end.
+ (wisi-goto-end-1 (ada-goto-declaration-start)))
;;;; fill-comment
-(defvar wisi-inhibit-parse nil);; in wisi.el; so far that's the only parser we
use.
-
(defun ada-fill-comment-paragraph (&optional justify postfix)
"Fill the current comment paragraph.
If JUSTIFY is non-nil, each line is justified as well.
If POSTFIX and JUSTIFY are non-nil, `ada-fill-comment-postfix' is appended
to each line filled and justified.
-The paragraph is indented on the first line."
+The ident for the paragraph is taken from the first line."
(interactive "P")
- (if (not (or (ada-in-comment-p)
+ (if (not (or (wisi-in-comment-p)
(looking-at "[ \t]*--")))
(error "Not inside comment"))
@@ -2647,6 +1026,9 @@ The paragraph is indented on the first line."
'("some")
"List of keywords new in Ada 2012.")
+(defvar ada-keywords nil
+ "List of Ada keywords for current `ada-language-version'.")
+
(defun ada-font-lock-keywords ()
"Return Ada mode value for `font-lock-keywords', depending on
`ada-language-version'."
;; Grammar actions set `font-lock-face' property for all
@@ -2655,41 +1037,459 @@ The paragraph is indented on the first line."
(list (concat "\\_<" (regexp-opt ada-keywords t) "\\_>") '(0
font-lock-keyword-face))
))
-(defvar which-func-functions nil) ;; which-func.el
-(defvar which-func-non-auto-modes nil) ;; ""
+;;;; auto-case
-;;;; ada-mode
+(defcustom ada-auto-case t
+ "When non-nil, automatically change case of preceding word while
+typing. Casing of Ada keywords is done according to `ada-case-keyword',
+identifiers according to `ada-case-identifier'."
+ :group 'ada
+ :type '(choice (const nil)
+ (const t))
+ :safe (lambda (val) (memq val '(nil t))))
+(make-variable-buffer-local 'ada-auto-case)
-;; ada-mode does not derive from prog-mode, because we need to call
-;; ada-mode-post-local-vars, and prog-mode does not provide a way to
-;; do that (at least before emacs 26).
-;;
-;; autoload required by automatic mode setting
-;;;###autoload
-(defun ada-mode ()
- "The major mode for editing Ada code."
- ;; the other ada-*.el files add to ada-mode-hook for their setup
+(defcustom ada-case-keyword 'lower-case
+ "Indicate how to adjust case for language keywords.
+Value is one of lower-case, upper-case."
+ :group 'ada
+ :type '(choice (const lower-case)
+ (const upper-case))
+ :safe #'symbolp)
+(make-variable-buffer-local 'ada-case-keyword)
+
+(defcustom ada-case-strict t
+ "If non-nil, force Mixed_Case for identifiers.
+Otherwise, allow UPPERCASE for identifiers."
+ :group 'ada
+ :type 'boolean
+ :safe #'booleanp)
+(make-variable-buffer-local 'ada-case-strict)
+
+(defcustom ada-case-identifier 'mixed-case
+ "Indicates how to adjust the case of Ada keywords."
+ :group 'ada
+ :type '(choice (const mixed-case)
+ (const lower-case)
+ (const upper-case))
+ :safe (lambda (val) (memq val '(mixed-case lower-case upper-case))))
+(make-variable-buffer-local 'ada-case-identifier)
+
+(defun ada-in-based-numeric-literal-p ()
+ "Return t if point is after a prefix of a based numeric literal."
+ (looking-back "\\([0-9]+#[0-9a-fA-F_]+\\)" (line-beginning-position)))
+
+(defun ada-case-adjust-p (typed-char)
+ "For `wisi-case-adjust-p-function'."
+ (and
+ ;; hex digits
+ (not (ada-in-based-numeric-literal-p))
+
+ ;; character literal
+ (not (and (eq typed-char ?')
+ (eq (char-before (point)) ?')))
+ ))
+
+;;;; wisi integration
+
+(defconst ada-wisi-language-protocol-version "3"
+ "Defines language-specific parser parameters.
+Must match wisi-ada.ads Language_Protocol_Version.")
+
+(cl-defstruct (ada-wisi-parser (:include wisi-process--parser))
+ ;; no new slots
+ )
+
+(cl-defmethod wisi-parse-format-language-options ((_parser ada-wisi-parser))
+ (format "%d %d %d %d %d %d %d %d %d %d %d %d %d"
+ ada-indent
+ ada-indent-broken
+ (if ada-indent-comment-col-0 1 0)
+ (if ada-indent-comment-gnat 1 0)
+ ada-indent-label
+ ada-indent-record-rel-type
+ ada-indent-renames
+ ada-indent-return
+ ada-indent-use
+ ada-indent-when
+ ada-indent-with
+ (if ada-indent-hanging-rel-exp 1 0)
+ (if ada-end-name-optional 1 0)
+ ))
+
+(defconst ada-wisi-named-begin-regexp
+ "\\bfunction\\b\\|\\bpackage\\b\\|\\bprocedure\\b\\|\\btask\\b"
+ )
+
+(defconst ada-wisi-partial-begin-regexp
+ (concat "\\bbegin\\b\\|\\bdeclare\\b\\|"
+ ada-wisi-named-begin-regexp
+ "\\|\\bend;\\|\\bend " ada-name-regexp ";"))
+
+(defconst ada-wisi-partial-end-regexp
+ (concat ada-wisi-partial-begin-regexp
+ "\\|;"))
+
+(defun ada-wisi-find-begin ()
+ "Starting at current point, search backward for a parse start point."
+
+ ;; There is a trade-off in deciding where to start parsing for indent. If we
have:
+ ;;
+ ;; procedure ...
+ ;; is
+ ;;
+ ;; and are inserting a new line after 'is', we need to include
+ ;; 'is' in the parse to see the indent. On the other hand, if we
+ ;; have:
+ ;;
+ ;; ...
+ ;; end;
+ ;; begin
+ ;; Foo;
+ ;;
+ ;; Inserting new line after 'Foo;'; if we include 'begin', there
+ ;; is no error (begin starts a statement), and the indent is
+ ;; computed incorrectly.
+ ;;
+ ;; This is handled by the set of keywords in
+ ;; ada-wisi-partial-begin-regexp.
+ (cond
+ ((wisi-search-backward-skip
+ ada-wisi-partial-begin-regexp
+ (lambda () (or (wisi-in-string-or-comment-p)
+ (looking-back "access " (line-beginning-position)))))
+ ;; "access" rejects subprobram access parameters;
test/ada_mode-recover_partial_20.adb
+
+ (let ((found (match-string 0))
+ cache)
+ (cond
+ ((and (>= (length found) 3)
+ (string-equal "end" (substring found 0 3)))
+ (match-end 0))
+
+ (t
+ (setq cache (wisi-get-cache (point)))
+ (when cache
+ ;; This distinguishes 'begin' as a statement start from
+ ;; 'begin' following 'declare', 'procedure' etc. We don't
+ ;; force a parse to get this; the user may choose to do so.
+ (wisi-goto-start cache))
+ (point))
+ )))
+
+ (t
+ (point-min))
+ ))
+
+(defun ada-wisi-find-end ()
+ "Starting at current point, search forward for a reasonable parse end point."
+ (forward-comment (point-max)) ;; get past any current comments
+ (forward-line 1) ;; contain at least some code (see
ada_mode-partial_parse.adb 'blank line before "end"')
+
+ (let ((start (point))
+ match
+ (end-cand nil))
+
+ (while (not end-cand)
+ (if (search-forward-regexp ada-wisi-partial-end-regexp nil 1) ;; moves
to eob if not found
+ (unless (or (wisi-in-string-or-comment-p)
+ (wisi-in-paren-p))
+ (setq match t)
+ (setq end-cand (point)))
+
+ ;; No reasonable end point found (maybe a missing right
+ ;; paren); return line after start for minimal parse, compute
+ ;; indent for line containing start.
+ (setq match nil)
+ (goto-char start)
+ (setq end-cand (line-end-position 2)))
+ )
+
+ (when (and match
+ (not (string-equal ";" (match-string 0))))
+ (setq end-cand (match-beginning 0)))
+
+ end-cand))
+
+(defun ada-wisi-find-matching-end ()
+ "Starting at current point, search forward for a matching end.
+Point must have been set by `ada-wisi-find-begin'."
+ (let (end-regexp)
+ ;; Point is at bol
+ (back-to-indentation)
+ (when (looking-at ada-wisi-named-begin-regexp)
+ (skip-syntax-forward "ws")
+ (skip-syntax-forward " ")
+ (when (looking-at "body\\|type")
+ (goto-char (match-end 0))
+ (skip-syntax-forward " "))
+ (setq end-regexp
+ (concat "end +"
+ (buffer-substring-no-properties
+ (point)
+ (progn
+ (skip-syntax-forward "ws._")
+ (point)))
+ ";"))
+ (if (search-forward-regexp end-regexp nil t)
+ (progn
+ (while (and (wisi-in-string-or-comment-p)
+ (search-forward-regexp end-regexp nil t)))
+ (point))
+
+ ;; matching end not found
+ nil)
+ )))
+
+(cl-defmethod wisi-parse-expand-region ((_parser ada-wisi-parser) begin end)
+ (let (begin-cand end-cand result)
+ (save-excursion
+ (goto-char begin)
+
+ (setq begin-cand (ada-wisi-find-begin))
+ (if (= begin-cand (point-min)) ;; No code between BEGIN and bob
+ (progn
+ (goto-char end)
+ (setq result (cons begin-cand (ada-wisi-find-end))))
+
+ (setq end-cand (ada-wisi-find-matching-end))
+ (if (and end-cand
+ (>= end-cand end))
+ (setq result (cons begin-cand end-cand))
+ (goto-char end)
+ (setq result (cons begin-cand (ada-wisi-find-end))))
+
+ ))
+ result))
+
+(cl-defmethod wisi-parse-adjust-indent ((_parser ada-wisi-parser) indent
repair)
+ (cond
+ ((or (wisi-list-memq (wisi--parse-error-repair-inserted repair) '(BEGIN IF
LOOP))
+ (wisi-list-memq (wisi--parse-error-repair-deleted repair) '(END)))
+ ;; Error token terminates the block containing the start token
+ (- indent ada-indent))
+
+ ((equal '(CASE IS) (wisi--parse-error-repair-inserted repair))
+ (- indent (+ ada-indent ada-indent-when)))
+
+ ((equal '(END CASE SEMICOLON) (wisi--parse-error-repair-inserted repair))
+ (+ indent (+ ada-indent ada-indent-when)))
+
+ (t indent)
+ ))
+
+(defun ada-wisi-comment-gnat (indent after)
+ "Modify INDENT to match gnat rules. Return new indent.
+INDENT must be indent computed by the normal indentation
+algorithm. AFTER indicates what is on the previous line; one of:
+
+code: blank line, or code with no trailing comment
+code-comment: code with trailing comment
+comment: comment"
+ (let (prev-indent next-indent)
+ ;; the gnat comment indent style check; comments must
+ ;; be aligned to one of:
+ ;;
+ ;; - multiple of ada-indent
+ ;; - next non-blank line
+ ;; - previous non-blank line
+ ;;
+ ;; Note that we must indent the prev and next lines, in case
+ ;; they are not currently correct.
+ (cond
+ ((and (not (eq after 'comment))
+ (= 0 (% indent ada-indent)))
+ ;; this will handle comments at bob and eob, so we don't
+ ;; need to worry about those positions in the next checks.
+ indent)
+
+ ((and (setq prev-indent
+ (if (eq after 'comment)
+ (progn (forward-comment -1) (current-column))
+ (save-excursion (forward-line -1)(current-indentation))))
+ (= indent prev-indent))
+ indent)
+
+ ((and (setq next-indent
+ ;; we use forward-comment here, instead of
+ ;; forward-line, because consecutive comment
+ ;; lines are indented to the current one, which
+ ;; we don't know yet.
+ (save-excursion (forward-comment
(point-max))(current-indentation)))
+ (= indent next-indent))
+ indent)
+ (t
+ (cl-ecase after
+ (code-comment
+ ;; After comment that follows code on the same line
+ ;; test/ada_mode-conditional_expressions.adb
+ ;;
+ ;; then 44 -- comment matching GNAT
+ ;; -- second line
+ ;;
+ ;; else 45)); -- comment _not_ matching GNAT style check
+ ;; -- comment matching GNAT
+ ;;
+ (+ indent (- ada-indent (% indent ada-indent))))
+
+ ((code comment)
+ ;; After code with no trailing comment, or after comment
+ ;; test/ada_mode-conditional_expressions.adb
+ ;; (if J > 42
+ ;; -- comment indent matching GNAT style check
+ ;; -- second line of comment
+ prev-indent)
+
+ ))
+ )))
+
+(defun ada-wisi-comment ()
+ "Modify indentation of a comment:
+For `wisi-indent-calculate-functions'.
+- align to previous comment after code.
+- respect `ada-indent-comment-gnat'."
+ ;; We know we are at the first token on a line.
+ ;;
+ ;; The normal indentation algorithm has already indented the
+ ;; comment.
+ (when (and (not (eobp))
+ (string= comment-start (buffer-substring-no-properties (point)
(min (point-max) (+ 2 (point))))))
+
+ ;; We are looking at a comment; check for preceding comments, code
+ (let (after
+ (indent (current-column)))
+ (if (save-excursion (forward-line -1) (looking-at "\\s *$"))
+ ;; after blank line
+ (setq after 'code)
+
+ (save-excursion
+ (forward-comment -1)
+ (if (or (not ada-indent-after-trailing-comment) ;; ignore comment on
previous line
+ (looking-at "\\s *$")) ;; no comment on
previous line
+ (setq after 'code)
+
+ (setq indent (current-column))
+ (if (not (= indent (progn (back-to-indentation) (current-column))))
+ ;; previous line has comment following code
+ (setq after 'code-comment)
+ ;; previous line has plain comment
+ (setq indent (current-column))
+ (setq after 'comment)
+ )))
+ )
+
+ (cl-ecase after
+ (code
+ (if ada-indent-comment-gnat
+ (ada-wisi-comment-gnat indent 'code)
+ indent))
+
+ (comment
+ indent)
+
+ (code-comment
+ (if ada-indent-comment-gnat
+ (ada-wisi-comment-gnat indent 'code-comment)
+
+ ;; After comment that follows code on the same line
+ ;; test/ada_mode-nominal.adb
+ ;;
+ ;; begin -- 2
+ ;; --EMACSCMD:(progn
(ada-goto-declarative-region-start)(looking-at "Bad_Thing"))
+ (save-excursion (forward-comment -1)(current-column)))
+ ))
+ )))
+
+(defun ada-wisi-post-parse-fail ()
+ "For `wisi-post-parse-fail-hook'."
+ ;; Parse indent succeeded, so we assume parse navigate will as well
+ (wisi-validate-cache (point-min) (line-end-position) nil 'navigate)
+ (save-excursion
+ (let ((start-cache (wisi-goto-start (or (wisi-get-cache (point))
(wisi-backward-cache)))))
+ (when start-cache
+ ;; nil when in a comment at point-min
+ (indent-region (point) (wisi-cache-end start-cache)))
+ ))
+ (back-to-indentation))
+
+(defun ada-find-file ()
+ "Find a file in the current project.
+Prompts with completion, defaults to filename at point."
+ (interactive)
+ ;; In emacs 27, we can just call 'project-find-file;
+ ;; project-read-file-name-function handles the uniquify-files alist
+ ;; completion table. In emacs 26, we must do that ourselves.
+ (cl-ecase emacs-major-version
+ (27
+ (project-find-file))
+
+ (26
+ (let* ((def (thing-at-point 'filename))
+ (project (project-current))
+ (all-files (project-files project nil))
+ (alist (uniq-file-uniquify all-files))
+ (table (apply-partially #'uniq-file-completion-table alist))
+ (file (project--completing-read-strict
+ "Find file" table nil nil def)))
+ (if (string= file "")
+ (user-error "You didn't specify the file")
+ (find-file (cdr (assoc file alist))))))
+ ))
+
+;;;; compatibility with previous ada-mode versions
+
+;;;###autoload
+(defun ada-fix-compiler-error ()
(interactive)
- (kill-all-local-variables)
- (setq major-mode 'ada-mode)
- (setq mode-name "Ada")
- (use-local-map ada-mode-map)
+ (wisi-fix-compiler-error))
+(make-obsolete 'ada-fix-compiler-error 'wisi-fix-compiler-error "ada-mode
7.0.0")
+
+(defun ada-select-prj-file-1 (prj-file)
+;; avoid byte compiler warning about obsolete ada-select-prj-file
+ (wisi-prj-select-cache
+ prj-file
+ (ada-prj-default
+ (file-name-sans-extension (file-name-nondirectory prj-file))
+ (file-name-directory prj-file)))
+
+ ;; We set project-find-functions, xref-backend-functions here for
+ ;; compatibility with ada-mode 6.x.
+ (unless (wisi-prj-find-function-set-p)
+ (add-hook 'project-find-functions #'wisi-prj-current-cached)
+ (add-hook 'xref-backend-functions #'wisi-prj-xref-backend)))
- (set-syntax-table ada-mode-syntax-table)
- (define-abbrev-table 'ada-mode-abbrev-table ())
- (setq local-abbrev-table ada-mode-abbrev-table)
+;;;###autoload
+(defun ada-parse-prj-file (prj-file)
+ (ada-select-prj-file-1 prj-file))
+(make-obsolete 'ada-parse-prj-file 'wisi-prj-select-cache "ada-mode 7.0.0")
+
+;;;###autoload
+(defun ada-select-prj-file (prj-file)
+ (ada-select-prj-file-1 prj-file))
+(make-obsolete 'ada-select-prj-file #'wisi-prj-select-cache "ada-mode 7.0.0")
+
+;;;###autoload
+(defalias 'ada-project-current #'wisi-prj-current-cached)
+(make-obsolete 'ada-project-current #'wisi-prj-current-cached "ada-mode 7.0.0")
+
+;;;; ada-mode
+
+(defvar which-func-functions nil) ;; which-func.el
+(defvar which-func-non-auto-modes nil) ;; ""
+
+;;;###autoload
+(define-derived-mode ada-mode prog-mode "Ada"
+ "The major mode for editing Ada code."
+ :group 'ada
(set (make-local-variable 'syntax-propertize-function)
'ada-syntax-propertize)
(syntax-ppss-flush-cache (point-min));; reparse with new function
- (when (boundp 'syntax-begin-function)
- ;; default ‘beginning-of-defun’ in emacs-24.2; we need it nil
- ;; obsolete in 25.1
- (set (make-local-variable 'syntax-begin-function) nil))
(set (make-local-variable 'parse-sexp-ignore-comments) t)
(set (make-local-variable 'parse-sexp-lookup-properties) t)
(set 'case-fold-search t); Ada is case insensitive; the syntax parsing
requires this setting
+ (set 'completion-ignore-case t)
(set (make-local-variable 'comment-start) "--")
(set (make-local-variable 'comment-end) "")
(set (make-local-variable 'comment-start-skip) "---*[ \t]*")
@@ -2716,7 +1516,7 @@ The paragraph is indented on the first line."
'ada-other-file-alist)
(setq ff-post-load-hook #'ada-set-point-accordingly
ff-file-created-hook #'ada-ff-create-body)
- (add-hook 'ff-pre-load-hook #'ada-goto-push-pos)
+ (add-hook 'ff-pre-load-hook #'push-mark)
(add-hook 'ff-pre-load-hook #'ada-which-function)
(setq ff-search-directories 'compilation-search-path)
(when (null (car compilation-search-path))
@@ -2741,6 +1541,9 @@ The paragraph is indented on the first line."
(set (make-local-variable 'align-region-separate) ada-align-region-separate)
(set (make-local-variable 'align-indent-before-aligning) t)
+ (set (make-local-variable 'beginning-of-defun-function)
#'ada-goto-declaration-start)
+ (set (make-local-variable 'end-of-defun-function) #'ada-goto-declaration-end)
+
;; Exclude comments alone on line from alignment.
(add-to-list 'align-exclude-rules-list
'(ada-solo-comment
@@ -2755,17 +1558,24 @@ The paragraph is indented on the first line."
(easy-menu-add ada-mode-menu ada-mode-map)
- (setq ada-case-strict (ada-prj-get 'case_strict))
-
- (run-mode-hooks 'ada-mode-hook)
-
- (when (< emacs-major-version 25) (syntax-propertize (point-max)))
-
- (if (<= emacs-major-version 25)
- ;; run-mode-hooks does _not_ call hack-local-variables
- (add-hook 'hack-local-variables-hook 'ada-mode-post-local-vars nil t)
- ;; >= 26; run-mode-hooks _does_ call hack-local-variables, after the hook
functions
- (ada-mode-post-local-vars))
+ (wisi-setup
+ :indent-calculate '(ada-wisi-comment)
+ :post-indent-fail 'ada-wisi-post-parse-fail
+ :parser
+ (wisi-process-parse-get
+ (make-ada-wisi-parser
+ :label "Ada"
+ :language-protocol-version ada-wisi-language-protocol-version
+ :exec-file ada-process-parse-exec
+ :exec-opts ada-process-parse-exec-opts
+ :face-table ada-process-face-table
+ :token-table ada-process-token-table
+ :repair-image ada-process-repair-image)))
+
+ (setq wisi-prj-parse-undefined-function #'ada-prj-parse-undefined)
+ (setq wisi-xref-full-path ada-xref-full-path)
+
+ (add-hook 'hack-local-variables-hook #'ada-mode-post-local-vars nil t)
)
(defun ada-mode-post-local-vars ()
@@ -2776,12 +1586,12 @@ The paragraph is indented on the first line."
;; This means to fully set ada-mode interactively, user must
;; do M-x ada-mode M-; (hack-local-variables)
- (setq hack-local-variables-hook (delq 'ada-mode-post-local-vars
hack-local-variables-hook))
+ (remove-hook 'hack-local-variables-hook #'ada-mode-post-local-vars)
;; fill-region-as-paragraph in ada-fill-comment-paragraph does not
;; call syntax-propertize, so set comment syntax on
;; ada-fill-comment-prefix. In post-local because user may want to
- ;; set it per-file. IMPROVEME: only in emacs < 25?
+ ;; set it per-file.
(put-text-property 0 2 'syntax-table '(11 . nil) ada-fill-comment-prefix)
(cl-case ada-language-version
@@ -2810,57 +1620,22 @@ The paragraph is indented on the first line."
;; ada-keywords
(font-lock-refresh-defaults))
- (when ada-goto-declaration-start
- (set (make-local-variable 'beginning-of-defun-function)
ada-goto-declaration-start))
+ (setq wisi-indent-comment-col-0 ada-indent-comment-col-0)
- (when ada-goto-declaration-end
- (set (make-local-variable 'end-of-defun-function)
ada-goto-declaration-end))
+ (setq wisi-auto-case ada-auto-case)
+ (setq wisi-case-identifier ada-case-identifier)
+ (setq wisi-case-strict ada-case-strict)
+ (setq wisi-language-keywords ada-keywords)
+ (setq wisi-case-keyword ada-case-keyword)
+ (setq wisi-case-adjust-p-function #'ada-case-adjust-p)
)
(put 'ada-mode 'custom-mode-group 'ada)
-(defvar ada-parser 'process
- "Indicate parser and lexer to use for Ada buffers:
-
-process : external process lexer and parser specified
- by ‘ada-process-parse-exec ’.
-"
- ;; As of ada-mode version 6.2, we no longer support the elisp
- ;; parser. We may add a module implementation at some point.
- )
-
-(defvar ada-fallback 'simple
- "Indicate fallback indentation engine for Ada buffers.
-
-simple: indent to previous line.")
-
-(provide 'ada-mode)
-
;;;;; Global initializations
-(add-hook 'menu-bar-update-hook #'ada-project-menu-install)
-
-(require 'ada-wisi)
-
-(cl-case ada-xref-tool
- (gnat (require 'ada-gnat-xref))
- (gpr_query (require 'gpr-query))
- (t
- (if (locate-file "gpr_query" exec-path '("" ".exe"))
- (progn
- (require 'gpr-query)
- (setq ada-xref-tool 'gpr_query))
- (require 'ada-gnat-xref)
- (setq ada-xref-tool 'gnat)))
- )
-
-(unless (featurep 'ada-compiler)
- (require 'ada-gnat-compile))
-
-(unless (featurep 'ada-skeletons)
- (require 'ada-skel))
-
(when (featurep 'imenu)
(require 'ada-imenu))
+(provide 'ada-mode)
;;; ada-mode.el ends here
diff --git a/packages/ada-mode/ada-mode.info b/packages/ada-mode/ada-mode.info
index 375f960..746829a 100644
--- a/packages/ada-mode/ada-mode.info
+++ b/packages/ada-mode/ada-mode.info
@@ -1,7 +1,7 @@
This is ada-mode.info, produced by makeinfo version 6.3 from
ada-mode.texi.
-Copyright (C) 1999 - 2019 Free Software Foundation, Inc.
+Copyright (C) 1999 - 2020 Free Software Foundation, Inc.
Permission is granted to copy, distribute and/or modify this
document under the terms of the GNU Free Documentation License,
@@ -25,7 +25,7 @@ File: ada-mode.info, Node: Top, Next: Overview, Prev:
(dir), Up: (dir)
Top
***
-Ada Mode Version 6.2.1
+Ada Mode Version 7.0.1
* Menu:
@@ -44,7 +44,6 @@ Ada Mode Version 6.2.1
* Key summary::
* Developer overview::
* GNU Free Documentation License::
-* Index::
-- The Detailed Node Listing --
@@ -55,13 +54,12 @@ Overview
Installation
* Ada Reference Manual::
-* gpr_query::
-* process parser::
+* Ada executables::
-gpr_query
+Ada executables
* Building GNATCOLL 2019::
-* Building gpr_query::
+* Building the executables::
Customizing Ada mode
@@ -82,7 +80,7 @@ Compiling Examples
* No project files:: Just menus
* Set compiler options:: A basic Ada mode project file
* Set source search path:: Source in multiple directories
-* Use GNAT project file::
+* Use wisi project file::
* Use multiple GNAT project files::
* Use a Makefile::
@@ -94,18 +92,10 @@ Project files
Developer overview
* Directory structure::
-* Package organization::
* ELPA::
* Savannah::
* ada-france::
-Package organization
-
-* Ada mode::
-* gpr mode::
-* GNAT core::
-* Wisi::
-
File: ada-mode.info, Node: Overview, Next: Installation, Prev: Top, Up: Top
@@ -152,8 +142,16 @@ File: ada-mode.info, Node: Why not LSP?, Up: Overview
The Language Server Protocol (LSP, <https://langserver.org>) supports an
external language parser, as Ada mode does, and it is supported by the
-GNU ELPA package eglot. We do not use LSP, because it does not support
-indentation and fontification.
+GNU ELPA package eglot. Ada mode does not use LSP mostly for historical
+reasons; the Ada mode parser was first developed before LSP was started.
+In addition, LSP does not support some of the navigation information
+provided by the Ada mode parser (although that could be provided as a
+custom command).
+
+ We may investigate supporting an LSP parser in the future. In
+particular, the AdaCore Gnat Studio editor uses an LSP parser for
+several functions; Emacs Ada mode could use that as a backend if it
+supports LSP.
File: ada-mode.info, Node: Installation, Next: Customization, Prev:
Overview, Up: Top
@@ -163,35 +161,30 @@ File: ada-mode.info, Node: Installation, Next:
Customization, Prev: Overview,
Ada mode requires Emacs 25.0 or greater. Compiling the Ada code for the
external process parser requires GNAT GPL 2017 or later; tested with
-GNAT Community Edition 2018 and GNAT Pro 19.
+GNAT Community Edition 2019 and GNAT Pro 19.
Ada mode is distributed in the Gnu ELPA package archive; it can be
-installed via 'M-x list-packages' (*note (emacs)Packages::). In Emacs <
-27 you must first enable packages in your '~/.emacs', _after_
-customizing 'Info-default-directory-list' (if you do that):
+installed via 'M-x list-packages' (*note (emacs)Packages::). Note that
+it requires the 'wisi' and 'uniquify-files' packages as dependencies.
- (package-initialize)
-
- Ada mode is also available as a separate distribution, from the Emacs
-Ada mode website
-<http://stephe-leake.org/emacs/ada-mode/emacs-ada-mode.html>.
+ In Emacs < 27 you must first enable packages in your '~/.emacs',
+_after_ customizing 'Info-default-directory-list' (if you do that):
- For installing the separate distribution, see the 'README' file in
-the distribution.
+ (package-initialize)
To see what version of Ada mode you have installed, invoke 'M-x
ada-mode-version'.
- You may also want to install additional utilities:
+ You must also install the associated Ada executables (for the
+language parser). You may want to install the Ada Reference Manual.
* Menu:
* Ada Reference Manual::
-* gpr_query::
-* process parser::
+* Ada executables::
-File: ada-mode.info, Node: Ada Reference Manual, Next: gpr_query, Prev:
Installation, Up: Installation
+File: ada-mode.info, Node: Ada Reference Manual, Next: Ada executables, Up:
Installation
2.1 Ada Reference Manual
========================
@@ -200,27 +193,42 @@ The ELPA package ada-ref-man includes the Ada Reference
Manual and
Annotated Ada Reference Manual in info format.
-File: ada-mode.info, Node: gpr_query, Prev: Ada Reference Manual, Up:
Installation
+File: ada-mode.info, Node: Ada executables, Prev: Ada Reference Manual, Up:
Installation
-2.2 gpr_query
-=============
+2.2 Ada executables
+===================
+
+Ada mode requires the external parser, which must be compiled.
-Ada mode has support for an external cross reference tool 'gpr_query',
-which uses compiler-generated information. In the case of Ada, the
-necessary '.ali' files are automatically generated by the standard
-compilation process. For other languages, e.g. C, C++, '.gli' files
-can be generated using the compiler switch '-fdump-xref'. '-fdump-xref'
-is an AdaCore extension, not available in FSF GCC.
+ Ada mode has support for an external cross reference tool
+'gpr_query', which uses compiler-generated information. In the case of
+Ada, the necessary '.ali' files are automatically generated by the
+standard compilation process. For other languages, e.g. C, C++, '.gli'
+files can be generated using the compiler switch '-fdump-xref'.
+'-fdump-xref' is an AdaCore extension, not available in FSF GCC.
'gpr_query' is an Ada program, which is distributed as source and
must be built. Its source code is in the 'ada-mode' Gnu ELPA package.
- 'gpr_query' requires the 'GNATCOLL' library provided by AdaCore,
-distributed with GNAT GPL 2017 or later, and also available at Github
-(<https://github.com/AdaCore/gnatcoll>). The notes below assume that
-the compiler is installed at '$prefix', e.g. '/usr/local/gnat-2019',
-and that '$prefix/bin' is first on the 'PATH'. If you are running
-Windows, use mingw64 'bash' to run these commands.
+ 'gpr_query' is similar to the AdaCore utility 'gnatxref', but
+supports additional queries.
+
+ Both the parser and 'gpr_query' require the 'GNATCOLL' library
+provided by AdaCore, distributed with GNAT GPL 2017 or later, and also
+available at Github (<https://github.com/AdaCore/gnatcoll>). The notes
+below assume that the compiler is installed at '$prefix', e.g.
+'/usr/local/gnat-2019', and that '$prefix/bin' is first on the 'PATH'.
+If you are running Windows, use mingw64 'bash' to run these commands.
+
+ On linux, some versions of the 'GNATCOLL.iconv' package (used by
+'gpr_query', but not the parser) explicity require the 'libiconv.so'
+library. GNAT provides the 'libiconv.so' library in
+'<gnat>/lib64/libiconv.so'. On Debian, that directory is not in the
+standard load path, and iconv is provided by glibc, so 'libiconv.so' is
+not found on the standard load path. So you must set LD_LIBRARY_PATH,
+but only when running 'gpr-query':
+
+ (setq gpr-query-env '("LD_LIBRARY_PATH=/Projects/gnat/pro_19.2/lib64")
In general, 'gpr_query' should be compiled with the compiler version
that is used to generate the user project '.ali' files; the 'ali' file
@@ -235,10 +243,10 @@ build gnatcoll xref from sources.
* Menu:
* Building GNATCOLL 2019::
-* Building gpr_query::
+* Building the executables::
-File: ada-mode.info, Node: Building GNATCOLL 2019, Next: Building gpr_query,
Up: gpr_query
+File: ada-mode.info, Node: Building GNATCOLL 2019, Next: Building the
executables, Up: Ada executables
2.2.1 Building GNATCOLL 2019
----------------------------
@@ -259,32 +267,29 @@ download" button, select "Download ZIP".
make -C xref install
-File: ada-mode.info, Node: Building gpr_query, Prev: Building GNATCOLL 2019,
Up: gpr_query
+File: ada-mode.info, Node: Building the executables, Prev: Building GNATCOLL
2019, Up: Ada executables
-2.2.2 Building 'gpr_query'
---------------------------
+2.2.2 Building the executables
+------------------------------
+
+'gpr_query' requires the 'pthread' library. On Windows, this is
+available in Mingw64 as package
+'mingw64/mingw-w64-x86_64-winpthreads-git'.
-To build and install 'gpr_query', assuming the 'ada-mode-6.0.xx' GNU
-ELPA package is installed:
+ To build and install 'gpr_query' and the parser, assuming the
+'ada-mode-6.0.xx' GNU ELPA package is installed:
cd ~/.emacs.d/elpa/ada-mode-6.0.xx
./build.sh
+ ./install.sh
- 'ada-mode' will use 'gpr_query' for cross reference functions if
-'gpr_query' is found in 'PATH'.
-
-
-File: ada-mode.info, Node: process parser
-
-2.3 process parser
-==================
+ By default, 'install.sh' installs the executables in the same
+directory as the GNAT executable (using 'gprinstall'). If you don't
+have write privileges there, or if you want to install somewhere else,
+use 'install.sh --prefix=<dir>'.
-The process parser is built and installed by the same 'build.sh' script
-as *Note gpr_query::. ada-mode will automatically use it if it is
-available.
-
- To override the automatic choice of parser, set ADA-PARSER to either
-''elisp' or ''parser'.
+ 'ada-mode' will use 'gpr_query' and the parser if they are found in
+'PATH'.
File: ada-mode.info, Node: Customization, Next: Compiling Executing, Prev:
Installation, Up: Top
@@ -311,13 +316,13 @@ File: ada-mode.info, Node: Slow response, Next:
Non-standard file names, Up:
3.1 Slow response
=================
-In large files, parsing is slow, so it gets in the way of interactive
-typing due to immediate fontification triggering a parse.
+In large files, parsing takes a noticable amount of time, so it gets in
+the way of interactive typing due to immediate fontification triggering
+a parse.
There are three ways to deal with this:
- 1. Install the process parser (*Note process parser::), and set
- 'wisi-partial-parse-threshold' appropriately in your '~./emacs':
+ 1. Set 'wisi-partial-parse-threshold' In your '~./emacs':
(setq wisi-partial-parse-threshold 100001)
@@ -325,17 +330,16 @@ typing due to immediate fontification triggering a parse.
on how fast your machine is, and what your tolerance for slow
response is.
- Files larger than 'wisi-partial-parse-threshold' will be parsed
- partially; only the part of the buffer needed for the current task
- will be parsed. For fontification, that is the visible part. For
- indent, it is approximately the current subprogram or package. For
- navigation, it is always the entire file, which will still be slow;
- that is the only way to ensure useful results.
+ Files larger than 'wisi-partial-parse-threshold' (in characters)
+ will be parsed partially; only the part of the buffer needed for
+ the current task will be parsed. For fontification, that is the
+ visible part. For indent, it is approximately the current
+ subprogram or package. For navigation, it is always the entire
+ file, which will still be slow; that is the only way to ensure
+ useful results.
With this setting, indentation may not be correct; the Ada menu
- entry "Edit | Indent lines in file" (or "Edit | Indent current
- statement", if point is on a keyword of a large enough enclosing
- statement) will parse the entire file and indent correctly.
+ entry "Edit | Indent containing statement" will indent correctly.
2. Delay fontification by setting 'jit-lock-defer-time' in your
'~./emacs':
@@ -371,7 +375,8 @@ spec and back.
Emacs and Ada mode support ways to use alternative file extensions
for specs and bodies. Note that you must also tell the compiler about
-these extensions; doing that is beyond the scope of this manual.
+these extensions in a GNAT project file Naming package; doing that is
+beyond the scope of this manual.
For instance, if your spec and bodies files are called 'UNIT_s.ada'
and 'UNIT_b.ada', respectively, you can add the following to your
@@ -407,15 +412,15 @@ File: ada-mode.info, Node: Other compiler, Next: Other
cross-reference, Prev:
3.3 Other compiler
==================
-The project variable 'ada_compiler' (default elisp variable
-'ada-compiler') is used to index several variables that point to the
+The wisi project variable 'ada_compoiler' (default elisp variable
+'ada-compiler') (default ''gnat') controls dispatching in
compiler-specific functions for corresponding Ada mode operations.
To use a compiler other than GNAT, you must write Emacs lisp code
that provides the interface to the compiler, and set 'ada-compiler' and
the indirection variables.
- See 'ada-gnat-compile.el' for an example.
+ See 'ada-compiler-gnat.el' for an example.
File: ada-mode.info, Node: Other cross-reference, Next: Other customization,
Prev: Other compiler, Up: Customization
@@ -423,8 +428,8 @@ File: ada-mode.info, Node: Other cross-reference, Next:
Other customization,
3.4 Other cross-reference
=========================
-The project variable 'ada_xref' (default elisp variable 'ada-xref-tool')
-is used to index several variables that point to the
+The wisi project variable 'xref_tool' (default elisp variable
+'ada-xref-tool') controls dispatching in the
cross-reference-tool-specific functions for corresponding Ada mode
operations.
@@ -444,8 +449,8 @@ File: ada-mode.info, Node: Other customization, Prev:
Other cross-reference,
=======================
All user-settable Ada mode variables can be set via the menu 'Ada |
-Customize'. Click on the 'Help' button there for help on using
-customize.
+Customize'; some can also be set in wisi project files (*note Project
+files::).
To modify a specific variable, you can directly call the function
'customize-variable'; just type 'M-x customize-variable <RET>
@@ -454,9 +459,11 @@ VARIABLE-NAME <RET>'.
Alternately, you can specify variable settings in the Emacs
configuration file, '~/.emacs'. This file is coded in Emacs lisp, and
the syntax to set a variable is the following:
+
(setq variable-name value)
Some general Emacs settings that are useful for Ada files:
+
'context menu'
By default, the context menu is bound to <C-down-mouse-3>, i.e.
control-right-click. <down-mouse-3> is already bound in the global
@@ -468,6 +475,17 @@ the syntax to set a variable is the following:
Gnu ELPA package 'other-frame-window'.
'delete-trailing-whitespace'
Deletes space, tab at end of line and blank lines at end of buffer.
+'xref configuration'
+ 'xref-prompt-for-identifier'
+ Set to 'nil' to be prompted less when finding definitions or
+ references.
+ 'xref-show-xrefs-function'
+ Determine placement of the window where references are shown.
+ 'xref-show-definitions-function'
+ Determine placement of the window where definitions are shown.
+ 'xref--transient-buffer-mode-map'
+ keymap used in some xref windows; you may want to disable the
+ <RET> binding there.
'untabify'
Deletes tab characters that have crept into the file.
'indent-tabs-mode'
@@ -481,9 +499,8 @@ the syntax to set a variable is the following:
Bind 'hippie-expand' to a key; it expands the word before point,
using words from current buffer, other buffers, file names, etc;
see 'hippie-expand-try-functions-list'. You can also add
- 'ada-skel-hippie-try' to that list. Note that 'ada-expand', which
- defaults to 'ada-skel-expand', is bound to <C-c C-e> (*note
- Statement skeletons::).
+ 'wisi-skel-hippie-try' to that list. Note that 'wisi-skel-expand'
+ is bound to <C-c C-e> (*note Statement skeletons::).
'imenu'
Navigate to subprograms and types by name, from a minibuffer menu.
'speedbar'
@@ -499,10 +516,15 @@ ada-mode does not set up the Ada-specific features of
imenu and speedbar
unless imenu is loaded first.
(setq-default indent-tabs-mode nil)
+ (define-key xref--transient-buffer-mode-map (kbd "RET") 'xref-goto-xref)
+ (setq xref-prompt-for-identifier nil) ;; only prompt on C-u
+ (setq xref-show-xrefs-function #'xref--show-defs-buffer-at-bottom)
+ (setq xref-show-definitions-function #'xref--show-defs-buffer-at-bottom)
+
(electric-pair-mode 1)
(require 'imenu) ;; also enables speedbar
(require 'ada-mode)
- (add-to-list 'hippie-expand-try-functions-list 'ada-skel-hippie-try)
+ (add-to-list 'hippie-expand-try-functions-list 'wisi-skel-hippie-try)
(define-key ada-mode-map "\C-e" 'hippie-expand)
(define-key ada-mode-map [down-mouse-3] 'ada-popup-menu)
(add-hook 'ada-mode-hook
@@ -526,8 +548,8 @@ GNAT compiler for simple projects (single files, or several
files in a
single directory).
For complex projects, you will want to use 'make' or some other build
-tool; in that case, you will need an Emacs Ada mode project file to tell
-Emacs about the project directory tree and other settings.
+tool; in that case, you may need a wisi project file to tell Emacs about
+the project directory tree and other settings.
* Menu:
@@ -542,7 +564,7 @@ File: ada-mode.info, Node: Compile commands, Next:
Compiling Examples, Prev:
====================
Here are the commands for building an Ada project and running the main
-program.
+program; they are all on the 'Ada | Build' menu.
In multi-file projects, there must be one file that is the main
program. That is given by the 'main' project file variable; it defaults
@@ -567,7 +589,7 @@ build" command.
Sets 'main' to the current file, then executes the Build command.
'Show main'
- Display 'main' in the message buffer.
+ Displays 'main' in the message buffer.
'Build'
Compiles all obsolete units of the current 'main', and links
@@ -588,7 +610,7 @@ build" command.
It is important when using these commands to understand how 'main' is
used and changed.
- Build runs 'gnatmake' on the main unit. During a typical
+ Build runs 'gprbuild' on the main unit. During a typical
edit/compile session, this is the only command you need to invoke, which
is why it is bound to 'C-c C-c'. It will compile all files needed by
the main unit, and display compilation errors in any of them.
@@ -631,7 +653,7 @@ website mentioned in *Note Installation::.
* No project files:: Just menus
* Set compiler options:: A basic Ada mode project file
* Set source search path:: Source in multiple directories
-* Use GNAT project file::
+* Use wisi project file::
* Use multiple GNAT project files::
* Use a Makefile::
@@ -647,13 +669,13 @@ This example uses no project files.
'hello.adb':
- with Ada.Text_IO;
+ with Ada.Text_Io;
procedure Hello
is begin
Put_Line("Hello from hello.adb");
end Hello;
- Yes, this is missing "use Ada.Text_IO;" - we want to demonstrate
+ Yes, this is missing "use Ada.Text_Io;" - we want to demonstrate
compiler error handling.
'hello_2.adb' has no errors:
@@ -672,18 +694,17 @@ compiler error handling.
'hello_pkg.adb':
- with Ada.Text_IO;
+ with Ada.Text_Io;
package Hello_Pkg is
procedure Say_Hello
is begin
- Ada.Text_IO.Put_Line ("Hello from hello_pkg.adb");
+ Ada.Text_Io.Put_Line ("Hello from hello_pkg.adb");
end Say_Hello;
end Hello_Pkg;
Yes, this is missing the keyword 'body'; another compiler error
example. However, note that the indentation engine parser accepts this
-code with no errors, making it easier to indent slightly illegal Ada
-code.
+code, making it possible to indent illegal Ada code.
In buffer 'hello.adb', invoke the menu entry 'Ada | Build | Check
syntax'. You should get a '*compilation*' buffer containing something
@@ -692,12 +713,14 @@ like (the directory paths will be different):
-*- mode: compilation; default-directory:
"c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_1/" -*-
Compilation started at Fri Oct 18 04:23:54
- gnatmake -u -c -gnatc
c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_1/hello.adb -cargs
- gcc -c -Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_1/ -gnatc
-I- c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_1/hello.adb
+ gprbuild -u -c -gnatc
c:/Projects/org.emacs.ada-mode/test/Example_1/hello.adb
+ using project file D:\Apps\GNAT-gpl_2019\share\gpr\_default.gpr
+ Compile
+ [Ada] hello.adb
hello.adb:4:04: "Put_Line" is not visible
hello.adb:4:04: non-visible declaration at a-textio.ads:263
hello.adb:4:04: non-visible declaration at a-textio.ads:259
- gnatmake:
"c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_1/hello.adb" compilation
error
+ gprbuild: *** compilation phase failed
Compilation exited abnormally with code 4 at Fri Oct 18 04:23:54
@@ -706,9 +729,9 @@ highlighted, with the file name in red.
Now invoke 'Ada | Build | Next compilation error'. Or you can click
the middle mouse button on the first error line, or use the key binding
-shown on the menu. The compilation buffer scrolls to put the first
-error on the top line, and point is put at the place of the error in the
-'hello.adb' buffer.
+shown on the menu. In the compilation buffer, a triangle is placed in
+the left fringe on the first error line, and point is put at the place
+of the error in the 'hello.adb' buffer.
To fix the error, invoke 'Ada | Build | Fix compilation error'; this
adds "Ada.Text_Io." to the line:
@@ -725,10 +748,15 @@ compilation buffer is displayed again, containing:
-*- mode: compilation; default-directory:
"c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_1/" -*-
Compilation started at Fri Oct 18 20:39:33
- gnatmake -o hello hello -cargs -bargs -largs
- gcc -c hello.adb
- gnatbind -x hello.ali
- gnatlink hello.ali -o hello.exe
+ gprbuild hello
+ using project file D:\Apps\GNAT-gpl_2019\share\gpr\_default.gpr
+ Compile
+ [Ada] hello.adb
+ Bind
+ [gprbind] hello.bexch
+ [Ada] hello.ali
+ Link
+ [link] hello.adb
Compilation finished at Fri Oct 18 20:39:34
@@ -754,11 +782,10 @@ error in 'hello_pkg.adb':
hello_pkg.adb:2:08: keyword "body" expected here [see file name]
- This demonstrates that gnatmake finds the files needed by the main
+ This demonstrates that gprbuild finds the files needed by the main
program. However, it cannot find files in a different directory, unless
-you use an Emacs Ada mode project file or a GNAT project file to specify
-the other directories; *Note Set source search path::, *note Use GNAT
-project file::.
+you use a GNAT project file to specify the other directories; *note Set
+source search path::.
Invoke 'Ada | Build | Show main'; this displays 'Ada mode main:
hello_2'.
@@ -768,7 +795,7 @@ hello_2'.
package body Hello_Pkg is
Now, while still in 'hello_pkg.adb', invoke 'Ada | Build | Build'.
-gnatmake successfully builds 'hello_2'. This demonstrates that Emacs
+gprbuild successfully builds 'hello_2'. This demonstrates that Emacs
has remembered the main file, in the project variable 'main', and used
it for the Build command.
@@ -794,8 +821,8 @@ File: ada-mode.info, Node: Set compiler options, Next:
Set source search path,
4.2.2 Set compiler options
--------------------------
-This example illustrates using an Emacs Ada mode project file to set a
-compiler option.
+This example illustrates using a gnat project file to set a compiler
+option.
If you have files from 'Example_1' open in Emacs, you should close
them so you don't get confused. Use menu 'File | Close (current
@@ -805,54 +832,58 @@ buffer)'.
'hello.adb':
- with Ada.Text_IO;
+ with Ada.Text_Io;
procedure Hello
is begin
Put_Line("Hello from hello.adb");
end Hello;
This is the same as 'hello.adb' from 'Example_1'. It has two errors;
-missing "use Ada.Text_IO;", and no space between 'Put_Line' and its
+missing "use Ada.Text_Io;", and no space between 'Put_Line' and its
argument list.
- 'hello.adp':
+ 'hello.gpr':
- comp_opt=-gnatyt
+ project Hello is
+ package Compiler is
+ for Default_Switches ("Ada") use ("-gnatyt");
+ end Compiler;
+ end Hello;
This tells the GNAT compiler to check for token spacing; in
particular, there must be a space preceding a parenthesis.
In buffer 'hello.adb', invoke 'Ada | Build | Set main and Build'.
-This finds the project file 'hello.adp', uses it to set the compiler
+This finds the project file 'hello.gpr', uses it to set the compiler
options, and builds the project. You should get a '*compilation*'
buffer containing something like (the directory paths will be
different):
- cd c:/Examples/Example_2/
- gnatmake -o hello hello -g -cargs -gnatyt -bargs -largs
- gcc -c -g -gnatyt hello.adb
+ gprbuild -Phello.gpr hello
+ Compile
+ [Ada] hello.adb
hello.adb:4:04: "Put_Line" is not visible
- hello.adb:4:04: non-visible declaration at a-textio.ads:264
- hello.adb:4:04: non-visible declaration at a-textio.ads:260
+ hello.adb:4:04: non-visible declaration at a-textio.ads:508
+ hello.adb:4:04: non-visible declaration at a-textio.ads:498
hello.adb:4:12: (style) space required
- gnatmake: "hello.adb" compilation error
+ gprbuild: *** compilation phase failed
Compare this to the compiler output in *note No project files::; the
-gnatmake option '-cargs' has been replaced by '-cargs -gnaty', and an
-additional error is reported in 'hello.adb' on line 4. This shows that
-'hello.adp' is being used to set the compiler options.
+compiler-provided default gpr file has been replaced by 'hello.gpr', and
+an additional error is reported in 'hello.adb' on line 4. This shows
+that 'hello.gpr' is being used to set the compiler options.
- Fixing the error, linking and running the code proceed as in *note No
-project files::.
+ Use 'C-x`', 'C-c M-`' to fix the errors, then 'Ada | Build | Build'
+and 'Ada | Build | Run' to build and run.
-File: ada-mode.info, Node: Set source search path, Next: Use GNAT project
file, Prev: Set compiler options, Up: Compiling Examples
+File: ada-mode.info, Node: Set source search path, Next: Use wisi project
file, Prev: Set compiler options, Up: Compiling Examples
4.2.3 Set source search path
----------------------------
In this example, we show how to deal with files in more than one
-directory, using an Emacs Ada mode project file to set the search path.
+directory, setting the source search path in the gpr file.
Create the directory 'Example_3', containing:
@@ -864,24 +895,30 @@ directory, using an Emacs Ada mode project file to set
the search path.
'hello_pkg.adb':
- with Ada.Text_IO;
+ with Ada.Text_Io;
package Hello_Pkg is
procedure Say_Hello
is begin
- Ada.Text_IO.Put_Line ("Hello from hello_pkg.adb");
+ Ada.Text_Io.Put_Line ("Hello from hello_pkg.adb");
end Say_Hello;
end Hello_Pkg;
These are the same files from example 1; 'hello_pkg.adb' has an error
on line 2.
- In addition, create a directory 'Example_3/Other', containing these
-files:
+ 'other.gpr':
+
+ project Other is
+ for Source_Dirs use (".", "Other");
+ end Other;
+
+ In addition, create a directory 'Example_3/Other', containing this
+file:
'Other/hello_3.adb':
with Hello_Pkg;
- with Ada.Text_IO; use Ada.Text_IO;
+ with Ada.Text_Io; use Ada.Text_Io;
procedure Hello_3
is begin
Hello_Pkg.Say_Hello;
@@ -890,48 +927,44 @@ files:
There are no errors in this file.
- 'Other/other.adp':
-
- src_dir=..
-
- Note that there must be no trailing spaces.
-
- In buffer 'hello_3.adb', invoke 'Ada | Project files | Find and set
-project...', and select 'Example_3/Other/other.adp'. This tells Emacs
+ In buffer 'hello_3.adb', invoke 'Ada | Project files | Find and
+select project...', and select 'Example_3/other.gpr'. This tells Emacs
Ada mode to stop using the project file from 'Example_2', and use the
one for 'Example_3'. Also note that since this project file is not
-named 'hello_3.adp', it would not be found by default.
+named 'hello_3.gpr', it would not be found by default.
Then, again in 'hello_3.adb', invoke 'Ada | Set main and Build'. You
should get a '*compilation*' buffer containing something like (the
directory paths will be different):
- cd c:/Examples/Example_3/Other/
- gnatmake -o hello_3 hello_3 -g -cargs -I.. -bargs -largs
- gcc -c -g -I.. hello_3.adb
- gcc -c -I./ -g -I.. -I- C:\Examples\Example_3\hello_pkg.adb
+ gprbuild -Pother.gpr hello_3
+ Compile
+ [Ada] hello_3.adb
+ [Ada] hello_pkg.adb
hello_pkg.adb:2:08: keyword "body" expected here [see file name]
- gnatmake: "C:\Examples\Example_3\hello_pkg.adb" compilation error
-
- Compare the '-cargs' option to the compiler output in *note Set
-compiler options::; this shows that 'other.adp' is being used to set the
-compiler options.
+ gprbuild: "C:\Examples\Example_3\hello_pkg.adb" compilation error
Move to the error with 'C-x `'. Ada mode searches the list of
-directories given by 'src_dir' for the file mentioned in the compiler
-error message.
+directories given by 'Source_Dirs' for the file mentioned in the
+compiler error message.
- Fixing the error, linking and running the code proceed as in *note No
-project files::.
+ Use 'C-x`', 'C-c M-`' to fix the errors, then 'Ada | Build | Build'
+and 'Ada | Build | Run' to build and run.
-File: ada-mode.info, Node: Use GNAT project file, Next: Use multiple GNAT
project files, Prev: Set source search path, Up: Compiling Examples
+File: ada-mode.info, Node: Use wisi project file, Next: Use multiple GNAT
project files, Prev: Set source search path, Up: Compiling Examples
-4.2.4 Use GNAT project file
+4.2.4 Use wisi project file
---------------------------
-In this example, we show how to use a GNAT project file, with no Ada
-mode project file.
+In this example, we show how to use a wisi project file to set some
+options that cannot be set in a gpr project file. In addition, we
+change a setting so you are prompted for a project file, rather than
+using a default one.
+
+ Change the setting:
+
+ M-x set-variable ada-build-prompt-prj search-prompt
Create the directory 'Example_4', containing:
@@ -943,73 +976,113 @@ mode project file.
'hello_pkg.adb':
- with Ada.Text_IO;
- package Hello_Pkg is
+ with Ada.Text_Io;
+ package body Hello_Pkg is
procedure Say_Hello
is begin
- Ada.Text_IO.Put_Line ("Hello from hello_pkg.adb");
+ Put_Line ("Hello from hello_pkg.adb");
end Say_Hello;
end Hello_Pkg;
- These are the same files from example 1; 'hello_pkg.adb' has an error
-on line 2.
+ These two files are the similar to files from example 1;
+'hello_pkg.adb' has an error on line 5 (missing "Ada.Text_IO.").
+
+ 'example_4.prj':
- In addition, create a directory 'Example_4/Gnat_Project', containing
-these files:
+ -- Wisi project file
- 'Gnat_Project/hello_4.adb':
+ gpr_project_path=More
+
+ gpr_file=example_4.gpr
+
+ casing=example_4.casing
+
+ 'example_4.prj' is a wisi project file; it specifies the
+'gpr_project_path', telling 'gprbuild' where to search for gpr files,
+and specifies the gpr file to use. Finally it specifies a casing
+exception file:
+
+ 'example_4.casing':
+
+ Text_IO
+
+ The default auto casing rules in ada-mode state that the Ada package
+"Ada.Text_IO" should be capitalized as "Ada.Text_Io", which does not
+match the Ada Reference Manual. 'example_4.casing' specifies that
+instead "Text_IO" should be capitalized as shown.
+
+ You can create a casing exception by editing the file directly, or
+via the 'Ada | Casing' menu.
+
+ 'gpr_project_path' and 'casing' are list variables; each occurence in
+a wisi project file adds an entry to the list.
+
+ In addition, create a directory 'Example_4/More', containing these
+files:
+
+ 'more/hello_4.adb':
with Hello_Pkg;
- with Ada.Text_IO; use Ada.Text_IO;
+ with Ada.Text_Io; use Ada.Text_Io;
procedure Hello_4
is begin
Hello_Pkg.Say_Hello;
Put_Line ("From hello_4");
end Hello_4;
- There are no errors in this file.
+ There are no errors in this file, except for the casing in
+"Ada.Text_Io".
- 'Gnat_Project/hello_4.gpr':
+ 'More/example_4.gpr':
- project Hello_4 is
+ project Example_4 is
for Source_Dirs use (".", "..");
- end Hello_4;
-
- In buffer 'hello_4.adb', invoke 'Ada | Project | Load...', and select
-'Example_4/Gnat_Project/hello_4.gpr'.
-
- Then, again in 'hello_4.adb', invoke 'Ada | Set main and Build'. You
-should get a '*compilation*' buffer containing something like (the
-directory paths will be different):
-
- -*- mode: compilation; default-directory:
"c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4/Gnat_Project/" -*-
- Compilation started at Mon Oct 21 11:28:31
-
- gnatmake
-Pc:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4/Gnat_Project/hello_4.gpr
-o hello_4 hello_4 -cargs -I.
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4/Gnat_Project
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4
-Ic:/Apps/GNAT-7.1.2/lib/gcc/i686-pc-mingw32/4.7.3/adainclude -bargs -largs
- gcc -c -I.
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4/Gnat_Project
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4
-Ic:/Apps/GNAT-7.1.2/lib/gcc/i686-pc-mingw32/4.7.3/adainclude -I- -gnatA
C:\Projects\org.emacs.ada-mode.stephe-1\test\Example_4\hello_pkg.adb
- hello_pkg.adb:2:08: keyword "body" expected here [see file name]
- gnatmake:
"C:\Projects\org.emacs.ada-mode.stephe-1\test\Example_4\hello_pkg.adb"
compilation error
- Compilation exited abnormally with code 4 at Mon Oct 21 11:28:31
-
- Compare the 'gcc' options to the compiler output in *note Set
-compiler options::; this shows that 'hello_4.gpr' is being used to set
-the compiler options.
-
- Fixing the error, linking and running the code proceed as in *note No
-project files::.
+ package Compiler is
+ for Default_Switches ("Ada") use ("-gnatyknpr");
+ end Compiler;
+ end Example_4;
+
+ The compiler switch checks all casing; we will get errors for
+"Ada.Text_Io".
+
+ Then, in 'hello_4.adb', invoke 'Ada | Set main and Build'. ada-mode
+looks for a project file 'hello_4.prj' or 'hello_4.gpr'; since neither
+is found, you are prompted to find a project file. Select
+'Example_4/example_4.prj'; that is parsed and selected, and the build
+continues.
+
+ You should get a '*compilation*' buffer containing something like
+(the directory paths will be different):
+
+ gprbuild -Pexample_4.gpr hello_4
+ Compile
+ [Ada] hello_pkg.adb
+ hello_pkg.adb:1:16: (style) bad casing of "Text_IO" declared at
a-textio.ads:57
+ hello_pkg.adb:5:07: "Put_Line" is not visible
+ hello_pkg.adb:5:07: non-visible declaration at a-textio.ads:508
+ hello_pkg.adb:5:07: non-visible declaration at a-textio.ads:498
+ gprbuild: *** compilation phase failed
+
+ When you fix the errors, note that 'C-c M-`' inserts the correct case
+for "Ada.Text_IO", and corrects the case where it is incorrect. The
+case is also corrected as you type; you can type "ada.text_io." and the
+case will be corrected when you type each "." or "_".
-File: ada-mode.info, Node: Use multiple GNAT project files, Next: Use a
Makefile, Prev: Use GNAT project file, Up: Compiling Examples
+File: ada-mode.info, Node: Use multiple GNAT project files, Next: Use a
Makefile, Prev: Use wisi project file, Up: Compiling Examples
4.2.5 Use multiple GNAT project files
-------------------------------------
In this example, we show how to use multiple GNAT project files,
specifying the GNAT project search path in an Ada mode project file.
+This also requires explicitly setting 'project-find-functions'.
- Create the directory 'Example_4' as specified in *note Use GNAT
-project file::.
+ If you haven't already, create the directory 'Example_4' as specified
+in *note Use wisi project file::. If you've already created it and run
+the tutorial, restore the compilation error in hello_pkg.adb; delete
+'Ada.Text_IO.' in front of 'Put_Line'.
Create the directory 'Example_5', containing:
@@ -1025,43 +1098,96 @@ project file::.
There are no errors in this file.
- 'hello_5.adp':
+ 'hello_5.prj':
- ada_project_path=../Example_4/Gnat_Project
+ gpr_project_path=../Example_4/More
gpr_file=hello_5.gpr
+ casing=../Example_4/example_4.casing
+
'hello_5.gpr':
- with "hello_4";
+ with "example_4";
project Hello_5 is
for Source_Dirs use (".");
package Compiler is
- for Default_Switches ("Ada") use ("-g", "-gnatyt");
+ for Default_Switches ("Ada") use ("-g", "-gnatyknprt");
end Compiler;
end Hello_5;
In buffer 'hello_5.adb', invoke 'Ada | Project | Find and select
-project...', and select 'Example_5/hello_5.adp'. This would also be
-found by default if no previous project file had been selected.
+project...', and select 'Example_5/hello_5.prj'. This would also be
+found by default if no previous project file had been selected. Note
+that if 'example_5.gpr' were named 'hello_5.gpr', the project file
+search would find more than one match, causing an error.
Then, again in 'hello_5.adb', invoke 'Ada | Build | Set main and
Build'. You should get a '*compilation*' buffer containing something
like (the directory paths will be different):
- -*- mode: compilation; default-directory:
"c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_5/" -*-
+ -*- mode: compilation; default-directory:
"c:/Projects/org.emacs.ada-mode/test/Example_5/" -*-
Compilation started at Mon Oct 21 11:32:05
- gnatmake
-Pc:/Projects/org.emacs.ada-mode.stephe-1/test/Example_5/hello_5.gpr -o hello_5
hello_5 -cargs -I. -Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_5
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4/Gnat_Project
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4
-Ic:/Apps/GNAT-7.1.2/lib/gcc/i686-pc-mingw32/4.7.3/adainclude -bargs -largs
- gcc -c -I. -Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_5
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4/Gnat_Project
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4
-Ic:/Apps/GNAT-7.1.2/lib/gcc/i686-pc-mingw32/4.7.3/adainclude -I- -gnatA
C:\Projects\org.emacs.ada-mode.stephe-1\test\Example_4\hello_pkg.adb
- hello_pkg.adb:2:08: keyword "body" expected here [see file name]
- gnatmake:
"C:\Projects\org.emacs.ada-mode.stephe-1\test\Example_4\hello_pkg.adb"
compilation error
-
- Compilation exited abnormally with code 4 at Mon Oct 21 11:32:05
+ gprbuild -Pexample_5.gpr hello_5
+ Compile
+ [Ada] hello_5.adb
+ [Ada] hello_pkg.adb
+ hello_pkg.adb:5:07: "Put_Line" is not visible
+ hello_pkg.adb:5:07: non-visible declaration at a-textio.ads:508
+ hello_pkg.adb:5:07: non-visible declaration at a-textio.ads:498
+ gprbuild: *** compilation phase failed
- Now type 'C-x `'. 'Example_4/hello_pkg.adb' is shown, demonstrating
+ Now type 'C-x `'; 'Example_4/hello_pkg.adb' is shown, demonstrating
that 'hello_5.gpr' and 'hello_4.gpr' are being used to set the
compilation search path.
+ Now, in buffer 'hello_pkg.adb' invoke the menu 'Ada | Navigate | Find
+file in project' (which calls 'ada-find-file') to get back to the
+'hello_5.adb' buffer. If you have not selected any project files
+previously in this emacs session, this gives an unexpected prompt for a
+"project directory". Kill that with 'C-g'. Otherwise, enter 'hel <tab>
+5 <tab>'; it will say "no match".
+
+ The problem here the way Emacs projects work. To find the current
+project, the functions in 'project-find-functions' are run; one should
+return a project. The ada-mode build functions add
+'wisi-prj-find-dominating-cached' to 'project-find-functions'; that
+looks in the current directory tree for a project file with the same
+name as one that was previously selected.
+
+ If 'Example_5' is the only project in the current emacs session,
+'wisi-prj-find-dominating-cached' finds no project file (because
+'Example_4' is not a child directory of 'Example_5', so the default
+strategy of "ask the user" is used, giving the prompt for a directory.
+
+ If 'Example_4' is also a project in the current emacs session,
+'wisi-prj-find-dominating-cached' finds that; since it does not contain
+'hello_5.adb', 'ada-find-file' cannot find it.
+
+ Any time you have a main project that depends on other projects that
+are not in the same directory tree, you will have this problem.
+
+ The fix is to use a different function in 'project-find-functions';
+'wisi-prj-current-cached'. This uses a global variable to indicate what
+the current project is. wisi provides four different functions for
+'project-find-functions'. *Note Selecting projects: (wisi)Selecting
+projects.
+
+ To change 'project-find-functions', execute:
+
+ M-: (remove-hook 'project-find-functions 'wisi-prj-find-dominating-cached)
+ M-: (add-hook 'project-find-functions 'wisi-prj-current-cached)
+
+ Normally, you must set 'project-find-functions' in your '~/.emacs',
+using the 'add-hook' function. The ada-mode Build menu functions set it
+for you to make things simpler for novices, but they do not change it if
+you have put one of the wisi functions on it.
+
+ Now set the current project; invoke 'Ada | Project | Find and select
+project...', and select 'Example_5/hello_5.prj'. Then in
+'hello_pkg.adb', invoke 'Ada | Navigate | Find file in project'; now we
+can find 'hello_5.adb'.
+
File: ada-mode.info, Node: Use a Makefile, Prev: Use multiple GNAT project
files, Up: Compiling Examples
@@ -1072,7 +1198,7 @@ In this example, we show how to use a Makefile to build
an Ada project
with GNAT, run the result, and clean the build directories.
Create the directories 'Example_4, Example_5' as specified in *note
-Use GNAT project file::, *note Use multiple GNAT project files::.
+Use wisi project file::, *note Use multiple GNAT project files::.
In 'Example_5', add the file:
@@ -1085,29 +1211,34 @@ Use GNAT project file::, *note Use multiple GNAT
project files::.
.PHONY : force
build : force
- gprbuild -Phello_5.gpr hello_5
+ gprbuild -PExample_5.gpr hello_5
run :
./hello_5
clean :
- gnatclean -r -Phello_5
-
- export GPR_PROJECT_PATH = ../Example_4/Gnat_Project
+ gnatclean -r -PExample_5
# Local Variables:
- # eval:(ada-parse-prj-file "hello_5.adp")
- # eval:(ada-select-prj-file "hello_5.adp")
+ # eval:(unless (wisi-prj-find-function-set-p)(add-hook
'project-find-functions 'wisi-prj-current-cached))
+ # eval:(wisi-prj-dtrt-parse-file "hello_5.prj" (ada-prj-default "hello_5
# main") "Makefile")
# End:
+ Tell Emacs to allow 'eval' in 'Local Variables':
+ M-: (setq enable-local-eval t)
+
Close and re-open 'Makefile'; the 'Local Variables' section sets the
-project file to 'hello_5.adp' when the 'Makefile' is opened. You can
-also use <C-x C-e> to execute the select line after the 'Makefile' is
-opened, to change the project file back to 'hello_5.adp'.
+project file to 'hello_5.prj' when the 'Makefile' is opened.
+
+ If you have set 'project-find-functions' in your '~/.emacs', you can
+leave out the first 'eval' line. Note that 'wisi-prj-dtrt-parse-file'
+does the right thing depending on which wisi function is in
+'project-find-functions'.
In 'Makefile', invoke 'Tools | Compile...', and accept the default
make command. This runs the 'all' target, which builds 'hello_5' and
-runs it.
+runs it (you may have to fix source errors first, depending on how fresh
+the Example_4 directory is).
File: ada-mode.info, Node: Compiler errors, Prev: Compiling Examples, Up:
Compiling Executing
@@ -1136,23 +1267,24 @@ File: ada-mode.info, Node: Project files, Next:
Moving Through Ada Code, Prev
5 Project files
***************
-An Emacs Ada mode project file specifies what directories hold sources
-for your project, and allows you to customize the compilation commands
-and other things on a per-project basis.
+Ada mode uses wisi project files; *note Project files: (wisi)wisi.
+
+ A wisi project file specifies what directories hold sources for your
+project, and allows you to customize the compilation commands and other
+things on a per-project basis.
- The default file extension for Ada mode project files is '*.adp' or
+ The default file extension for wisi project files is '*.adp' or
'*.prj'. You can use a different extension by adding it to
'ada-prj-file-extensions', and a different syntax by adding a parser
function to 'ada-prj-parser-alist'.
- Note that Ada mode project files '*.adp' are different than GNAT
-compiler project files '*.gpr'. However, Emacs Ada mode can use a GNAT
-project file to specify the project directories. If no other
-customization is needed, a GNAT project file can be used without an
-Emacs Ada mode project file.
+ Note that wisi project files are different than GNAT compiler project
+files ('*.gpr'). However, Emacs Ada mode can use a GNAT project file to
+specify the project directories. If no other customization is needed, a
+GNAT project file can be used without a wisi project file.
- If no Emacs Ada mode project file is specified, some Ada mode
-functions are not available.
+ If no wisi project file is specified, some Ada mode functions are not
+available.
* Menu:
@@ -1165,40 +1297,15 @@ File: ada-mode.info, Node: Project file overview,
Next: Project file variables
5.1 Project file overview
=========================
-Project files have a simple syntax; they may be edited directly. Each
-line specifies a project variable name and its value, separated by "="
-(spaces not allowed):
- src_dir=/Projects/my_project/src_1
- src_dir=/Projects/my_project/src_2
-
- Any line that does not have an "=" is a comment.
-
- Some variables (like 'src_dir') are lists; multiple occurrences are
-concatenated.
+The current project file is shown by the menu command <Ada | Project
+Files | Show project>.
- There must be no space between the variable name and "=", and no
-trailing spaces after the value.
-
- The current project file is given by the lisp variable
-'ada-prj-default-project-file', and shown by the menu command <Ada |
-Project Files | Show project>.
-
- To set the project file, use the menu command 'Ada | Set Project
-...', or the elisp functions 'ada-parse-prj-file, ada-select-prj-file'.
-The latter can be added to a Makefile:
-
- # Local Variables:
- # eval: (ada-parse-prj-file "ada-mode.prj")
- # eval: (ada-select-prj-file ada-mode.prj")
- # End:
+ To set the project file, use the menu command <Ada | Project Files |
+Find and select Project ...>, or one of the elisp functions described in
+*note Selecting Projects: (wisi)wisi.
- You specify either a GNAT project file or an Emacs Ada mode project
-file; if the file extension is '.gpr', the file is treated as a GNAT
-project file. Extensions given by 'ada-prj-file-extensions' (default
-'.adp, .prj') are treated as an Emacs Ada mode project file.
-
- After a project file is parsed, you can make it current again with
-just 'ada-select-prj-file', or by selecting it from the menu.
+ The project file may also be a GNAT project file (with file extension
+is '.gpr').
File: ada-mode.info, Node: Project file variables, Prev: Project file
overview, Up: Project files
@@ -1206,110 +1313,80 @@ File: ada-mode.info, Node: Project file variables,
Prev: Project file overview
5.2 Project file variables
==========================
-To set a project variable that is a list, specify each element of the
-list on a separate line in the project file. The value on the last line
-is the last element in the list.
-
- A variable name that starts with '$' is set as a process environment
-variable, for processes launched from Emacs for the project.
-
- In variable values, process environment variables can be referenced
-using the normal '$var' syntax.
-
- Most project variables have defaults that can be changed by setting
+Some project variables have defaults that can be changed by setting
elisp variables; the table below identifies the elisp variable for each
project variable. Elisp variables corresponding to project variables
that are lists are elisp lists.
- In general, project variables are evaluated when referenced in Emacs
-Ada mode commands. Relative file paths are expanded relative to the
-directory containing the project file.
-
- Ada mode defines some project variables; others are defined by the
-compiler.
+ wisi defines some project variables, Ada mode defines some, others
+are defined by the compiler and the cross reference tool.
- Here is the list of variables valid for all compilers. In the
-default values, the current directory '"."' is the directory containing
-the project file.
+ Here is the list of variables valid defined by wisi and Ada mode. In
+the default values, the current directory '"."' is the directory
+containing the project file.
'ada_compiler' [default: 'ada-compiler, gnat']
- Ada compiler for this project. It must occur in the project file
- before any compiler-specific project variable.
-
-'auto_case' [default: 'ada-auto-case, t']
- Non-nil means automatically change case of preceding word while
- typing.
+ Ada compiler for this project.
-'case_identifier' [default: 'ada-case-identifier, mixed-case']
- Indicates how to adjust the case of an Ada identifier.
+ Setting this in the project file reinitializes all options for the
+ xref tool, so it must occur before any compiler-specific project
+ variable.
-'case_keyword' [default: 'ada-case-keyword, lower-case']
- Indicates how to adjust the case of an Ada keyword.
-
-'case_strict' [default: 'ada-case-strict, t']
- If non-nil, 'ada-mixed-case' forces 'Mixed_Case' for identifiers.
- Otherwise, 'ada-mixed-case' allows 'UPPERCASE' for identifiers.
-
-'casing' [default: 'ada-case-exception-file, nil']
+'casing'
List of files containing casing exceptions. *Note Automatic
- casing::.
+ casing: Automatic casing.
+
+'gnat-stub-args'
+ List of strings passed to 'gnat stub' when it is run.
-'el_file' [default: ]
- The value is a file name, which is loaded as an elisp file when the
- project file is parsed or selected. This allows setting Ada mode
- indentation variables, and any arbitrary elisp code used to
- customize the project.
+'gnat-stub-cargs'
+ List of strings passed to 'gnat stub' after '-cargs'.
-'obj_dir' [default: '"."']
+'obj_dir'
A list of directories to search for object and cross-reference
files. Only needed if you are not using GPR files.
-'path_sep' [default: 'path-separator']
- Separator character used in compiler search paths.
-
-'src_dir' [default: '"."']
+'src_dir'
A list of directories to search for source files. Added to the
- source directories from a GPR file.
+ source directories from a gpr file (if any).
'xref_tool' [default: 'ada-xref-tool']
Cross reference tool for this project.
+ Setting this in the project file reinitializes all options for the
+ xref tool, so it must occur in the project file before any other
+ settings that affect the xref tool.
+
If 'gpr_query' is found in 'PATH', 'ada-xref-tool' defaults to
''gpr_query'. Otherwise, it defaults to ''gnat', which uses 'gnat
find'.
- The following variables are valid with the GNAT compiler:
+ The following project file variables are defined by the GNAT
+compiler:
-'ada_project_path' [default: '""']
- A list of directories to search for GNAT project files.
+'ada_project_path' [default: ]
+ Same as 'gpr_project_path'; see below.
- If set, the 'GPR_PROJECT_PATH' process environment variable is set
- to this value in the child process that runs GNAT tools. If not
- set, 'GPR_PROJECT_PATH' in the child process is inherited from the
- Emacs process.
-
- If you have the 'GPR_PROJECT_PATH' or 'ADA_PROJECT_PATH'
- environment variable set in the Emacs process correctly for all of
- your projects, you do not need to set this project variable.
-
- The project search path can also be set in GNAT aggregate projects.
- However, the gnat tools do not make that path available to Emacs,
- so you must duplicate it in an Emacs Ada project file.
-
-'gpr_file' [default: '""']
- The GNAT project file.
+'gpr_file' [default: ]
+ The GNAT project file for the project.
If set, the source and project directories specified in the GNAT
- project file are appended to 'src_dir' and 'ada_project_path'.
+ project file are appended to 'src_dir' and 'gpr_project_path'.
This allows specifying Ada source directories with a GNAT project
file, and other source directories with the Emacs project file.
-'gpr_project_path' [default: '""']
- Same as 'ada_project_path'.
+'gpr_project_path' [default: ]
+ A list of directories to search for GNAT project files. The list
+ is passed to tools via the 'GPR_PROJECT_PATH' process environment
+ variable in the process used to run the 'gnat' and 'gpr_query'
+ tools.
-'runtime' [default: 'nil']
+ If not set, 'GPR_PROJECT_PATH' in the child process is inherited
+ from the Emacs process.
+
+'runtime' [default: ]
If set, the name of the runtime, used as the value of the 'RTS'
- command line option.
+ command line option for tools.
'target' [default: 'nil']
If set, the name of the cross-compilation target, prepended to the
@@ -1347,6 +1424,9 @@ compiler, but others can be added (*note Other
cross-reference::).
Move from any use of an identifier to its declaration, for from a
declaration to its body (if there is one).
+ This runs 'xref-find-definitions', which has a default global
+ binding of <M-.>
+
'C-c M-d'
Move from a child type declaration to the parent type declaration;
display a list of references if there is more than one parent.
@@ -1356,11 +1436,17 @@ compiler, but others can be added (*note Other
cross-reference::).
For example, if point is on 'if', move to 'then'.
+ This runs 'forward-sexp', which has a default global binding of
+ 'C-M-f'.
+
'C-c C-p'
Move to the previous keyword in the current statement.
For example, if point is on 'then', move to 'if'.
+ This runs 'backward-sexp', which has a default global binding of
+ 'C-M-b'.
+
'C-c C-o'
Switch between corresponding spec and body. There are several
special cases:
@@ -1402,7 +1488,8 @@ compiler, but others can be added (*note Other
cross-reference::).
'Ada | Misc | Refresh cross reference cache'
Cross reference information is loaded from the compiler output when
- the first cross reference command is issued. If the code is
+ the first cross reference command is issued (or when the project
+ file is parsed, if useing cached project files). If the code is
recompiled after that, the cross reference information is reloaded
by invoking this menu command.
@@ -1417,6 +1504,8 @@ Emacs provides a general way of completing identifiers:
'M-/' (bound to
type the first few letters of an identifier, and then loop through all
the possible completions.
+ If you have bound 'hippie-expand', that also uses 'dabbrev-expand'.
+
'M-/' works by parsing all open Ada files for possible completions.
For instance, if the words 'my_identifier' and 'my_subprogram' are
@@ -1507,8 +1596,8 @@ can also configure the indentation, via the following
variables:
Indentation for the lines in a 'with' context clause.
The indentation variables are buffer local; the global value may be
-overridden in an elisp file invoked by an 'el_file' Emacs Ada mode
-project file statement, or in a file local variable section.
+overridden in an elisp function on 'ada-mode-hook', or in a file local
+variable section.
The following keys indent portions of the text:
@@ -1521,43 +1610,15 @@ project file statement, or in a file local variable
section.
'C-c TAB'
Indent the current statement or declaration.
- The indentation algorithm relies on a grammar parser to identify the
-syntactic role for keywords and other words in the code. If the code is
-accepted by the parser, the indentation is done according to the rules
-in the indentation engine.
-
- If the code is not accepted (because it is partially complete during
-editing), the indentation engine falls back to the trivial algorithm of
-indenting each new line the same as the previous line. Once enough new
-text has been entered to make the code acceptable to the parser, the
-statement or declaration is properly indented.
+'C-c S-TAB'
+ Indent the statement or declaration containing the current
+ statement or declaration.
- For example, if you are entering this code:
-
- if A then
- B;
- end if;
-
- when you type 'RET B', 'B' is indented to the same column as 'if',
-because the parser does not find 'end if;'. Then when you type the
-final ';' followed by <TAB>, all three lines are indented, putting 'B'
-where it belongs.
-
- To be more user friendly, the parser accepts a superset of the Ada
-grammer. For example, the parser accepts this code for an 'if'
-statement:
-
- if then
- end if;
-
- In general, any sequence of statements, and many expressions, may be
-omitted.
-
- One way to easily insert empty statements like this is using *note
-Statement skeletons::.
+ The indentation algorithm relies on a grammar parser to identify the
+syntactic role for keywords and other words in the code.
In rare cases, the parser gets confused; it can be reset by invoking
-menu <Ada | Misc | Reset parser>. Please report such cases as a bug.
+menu <Ada | Misc | Restart parser>. Please report such cases as a bug.
File: ada-mode.info, Node: Statement skeletons, Next: Aligning code, Prev:
Indentation, Up: Top
@@ -1565,7 +1626,7 @@ File: ada-mode.info, Node: Statement skeletons, Next:
Aligning code, Prev: In
9 Statement skeletons
*********************
-'C-c C-e' expands the previous one or two words into a statment
+'C-c C-e' expands the previous one or two words into a statement
skeleton. For example, 'i f C-c C-e' expands to:
if then
@@ -1573,9 +1634,6 @@ skeleton. For example, 'i f C-c C-e' expands to:
else
end if;
- All skeleton expansions are accepted by the indentation parser, so
-this is a convenient way to insert statements with correct indentation.
-
For named statements (packages, loops, etc), the name is taken from
the word before point, and the name of the statement from the word
before that.
@@ -1679,35 +1737,21 @@ automatically cased.
exception.
You can define exceptions to these rules, in files specified by the
-variable 'ada-case-exception-file'. Each line in a case exception file
-specifies the casing of one word or word fragment. If an exception is
-defined in multiple files, the first occurrence is used.
+'casing' project variable; *note Casing exception files: (wisi)Casing
+exception files.
- If the word starts with an asterisk ('*'), it defines the casing of a
-word fragment (or "substring"); part of a word between two underscores
-or word boundary.
-
- For example:
-
- DOD
- *IO
- GNAT
-
- The word fragment '*IO' applies to any word containing "_io";
-'Text_IO', 'Hardware_IO', etc.
-
- There are two ways to add new items to this file: you can simply edit
-it as you would edit any text file. Or you can position point on the
-word you want to add, and select menu 'Ada | Casing | Create full
-exception' or 'Ada | Casing | Create partial exception'. The word will
-be added to the current list of exceptions and to the file.
+ There are two ways to add new items to a casing exception file: you
+can simply edit it as you would edit any text file, or you can position
+point on the word you want to add, and select menu 'Ada | Casing |
+Create full exception' or 'Ada | Casing | Create partial exception'.
+The word will be added to the current list of exceptions and to the
+file.
It is sometimes useful to have multiple exception files. For
example, one could be the standard Ada acronyms, the second some company
specific exceptions, and the last one some project specific exceptions.
-If you set up the variable 'ada-case-exception-file' as a list of files,
-each of them will be parsed and used in your emacs session. When you
-create a new exception, you are prompted for the file to save it in.
+When you create a new exception, you are prompted for the file to save
+it in.
Other keys and menu entries are defined:
@@ -1773,6 +1817,10 @@ displays keys bound to menu operations.
'C-c TAB'
*Note Indentation::. Indent the current statement or declaration.
+'C-c S-TAB'
+ *Note Indentation::. Indent the containing statement or
+ declaration.
+
'C-c `'
*Note Compiler errors::. Move to the location of the secondary
reference in the current compilation error.
@@ -1848,13 +1896,12 @@ here's an overview.
* Menu:
* Directory structure::
-* Package organization::
* ELPA::
* Savannah::
* ada-france::
-File: ada-mode.info, Node: Directory structure, Next: Package organization,
Prev: Developer overview, Up: Developer overview
+File: ada-mode.info, Node: Directory structure, Next: ELPA, Up: Developer
overview
14.1 Directory structure
========================
@@ -1942,122 +1989,9 @@ File: ada-mode.info, Node: Directory structure, Next:
Package organization, P
More tests; allows testing path search features.
-File: ada-mode.info, Node: Package organization, Next: ELPA, Prev:
Directory structure, Up: Developer overview
-
-14.2 Package organization
-=========================
-
-* Menu:
-
-* Ada mode::
-* gpr mode::
-* GNAT core::
-* Wisi::
+File: ada-mode.info, Node: ELPA, Next: Savannah, Prev: Directory structure,
Up: Developer overview
-
-File: ada-mode.info, Node: Ada mode, Next: gpr mode, Prev: Package
organization, Up: Package organization
-
-14.2.1 Ada mode
----------------
-
-Ada mode consists of all files with 'ada-' prefix in the file name.
-
-'ada-mode.el'
- The main file, implementing the keymap, menu, and top level
- functionality.
-
- It allows for different backend implementations for compiling,
- cross-referencing, and indenting. The functions for each of these
- backends dispatch thru global variables that are set by Emacs Ada
- mode project files. They default to the GNAT compiler, the
- gnatxref cross reference tool, and the ada-wisi indentation engine.
-
-'ada-build.el'
- Provides functions for compiling Ada files without a Makefile (or
- similar tool).
-
-'ada-fix-error.el'
- Provides an interface to utilities for automatically fixing errors
- reported by the compiler. It dispatches to a compiler-specific
- backend.
-
-'ada-gnat-compile.el'
- Implements the Ada mode compiler functions for the GNAT compiler.
-
-'ada-gnat-xref.el'
- Implements the Ada mode cross reference functions for the GNAT
- compiler.
-
-'ada.wy'
- The Ada language grammar.
-
-'ada-indent-user-options.el'
- All user-settable options for the Ada indentation engine.
-
-'ada-mode-compat.el'
- Defines functions used by Ada mode that are not in older versions
- of Emacs.
-
-'ada-mode.texi'
- This Ada mode user guide source.
-
-'ada-skel.el'
- Skeletons for expansion of Ada syntax (*note Statement
- skeletons::). Extends the Emacs skeleton functions with "tokens",
- inspired by the lamented Else package (which was inspired by DEC
- LSE).
-
-'ada-wisi.el'
- Implements the Ada mode indentation functions for the wisi
- indentation engine backend.
-
-
-File: ada-mode.info, Node: gpr mode, Next: GNAT core, Prev: Ada mode, Up:
Package organization
-
-14.2.2 gpr mode
----------------
-
-gpr mode consists of all files with 'gpr-' prefix in the file name. The
-functions in each file are similar to the similarly-named Ada mode
-files.
-
-
-File: ada-mode.info, Node: GNAT core, Next: Wisi, Prev: gpr mode, Up:
Package organization
-
-14.2.3 GNAT core
-----------------
-
-'gnat-core.el'
- GNAT is actually a multi-language tool; it builds on top of the
- multi-language gcc.
-
- 'gnat-core.el' is a start at a language-agnostic interface to the
- GNAT tools. It was first factored out from 'ada-gnat.el' and
- 'ada-mode.el' to support the multi-language 'gpr_query.el'.
-
- More code currently in 'ada-mode.el' could be migrated to
- 'gnat-core.el', in particular the project file support.
-
-'gpr-query.el'
- Provides an interface to the external multi-language
- cross-reference tool 'gpr_query'.
-
- Implements the Ada mode cross-reference functions for the
- 'gpr_query' backend, and a minor mode providing similar functions
- for C++.
-
-
-File: ada-mode.info, Node: Wisi, Prev: GNAT core, Up: Package organization
-
-14.2.4 Wisi
------------
-
-The "wisi" parser. *Note Overview: (wisi)Overview.
-
-
-File: ada-mode.info, Node: ELPA, Next: Savannah, Prev: Package
organization, Up: Developer overview
-
-14.3 ELPA
+14.2 ELPA
=========
Ada mode is published via the Gnu ELPA archive. To test a new version
@@ -2078,7 +2012,7 @@ elpa workspace, and for building the elpa archive there.
File: ada-mode.info, Node: Savannah, Next: ada-france, Prev: ELPA, Up:
Developer overview
-14.4 Savannah
+14.3 Savannah
=============
The ada-mode web page, mailing list, and tarball download are hosted on
@@ -2089,14 +2023,14 @@ admin page there for more information.
File: ada-mode.info, Node: ada-france, Prev: Savannah, Up: Developer
overview
-14.5 ada-france
+14.4 ada-france
===============
The source code for ada-mode is maintained in a monotone repository in
the ada-france server <mtn://www.ada-france.org>.
-File: ada-mode.info, Node: GNU Free Documentation License, Next: Index,
Prev: Developer overview, Up: Top
+File: ada-mode.info, Node: GNU Free Documentation License, Prev: Developer
overview, Up: Top
Appendix A GNU Free Documentation License
*****************************************
@@ -2577,86 +2511,49 @@ recommend releasing these examples in parallel under
your choice of free
software license, such as the GNU General Public License, to permit
their use in free software.
-
-File: ada-mode.info, Node: Index, Prev: GNU Free Documentation License, Up:
Top
-
-Index
-*****
-
- [index ]
-* Menu:
-
-* ada-case-adjust-at-point: Automatic casing. (line 64)
-* ada-case-create-exception: Automatic casing. (line 48)
-* ada-find-other-file: Moving Through Ada Code.
- (line 32)
-* ada-goto-declaration: Moving Through Ada Code.
- (line 14)
-* ada-goto-declaration-parent: Moving Through Ada Code.
- (line 18)
-* ada-next-statement-keyword: Moving Through Ada Code.
- (line 22)
-* ada-prev-statement-keyword: Moving Through Ada Code.
- (line 27)
-* ada-show-overridden: Moving Through Ada Code.
- (line 65)
-* ada-show-overriding: Moving Through Ada Code.
- (line 60)
-* ada-show-references: Moving Through Ada Code.
- (line 55)
-* comment-dwim: Comment Handling. (line 10)
-* fill-paragraph: Comment Handling. (line 18)
-
Tag Table:
Node: Top931
-Node: Overview2824
-Node: Why not LSP?4061
-Node: Installation4403
-Node: Ada Reference Manual5460
-Node: gpr_query5736
-Node: Building GNATCOLL 20197377
-Node: Building gpr_query7950
-Node: process parser8357
-Node: Customization8689
-Node: Slow response9189
-Node: Non-standard file names11077
-Node: Other compiler12918
-Node: Other cross-reference13497
-Node: Other customization14239
-Node: Compiling Executing17459
-Node: Compile commands18194
-Node: Compiling Examples20845
-Node: No project files21677
-Node: Set compiler options27043
-Node: Set source search path29005
-Node: Use GNAT project file31458
-Node: Use multiple GNAT project files34232
-Node: Use a Makefile36952
-Node: Compiler errors38267
-Node: Project files39084
-Node: Project file overview40111
-Node: Project file variables41655
-Node: Moving Through Ada Code46530
-Node: Identifier completion49229
-Node: Indentation50191
-Node: Statement skeletons54761
-Node: Aligning code56546
-Node: Automatic casing57491
-Node: Comment Handling60219
-Node: Key summary60738
-Node: Developer overview63375
-Node: Directory structure63729
-Node: Package organization66459
-Node: Ada mode66689
-Node: gpr mode68470
-Node: GNAT core68753
-Node: Wisi69587
-Node: ELPA69746
-Node: Savannah70384
-Node: ada-france70736
-Node: GNU Free Documentation License70975
-Node: Index96136
+Node: Overview2716
+Node: Why not LSP?3953
+Node: Installation4709
+Node: Ada Reference Manual5675
+Node: Ada executables5936
+Node: Building GNATCOLL 20198294
+Node: Building the executables8879
+Node: Customization9702
+Node: Slow response10202
+Node: Non-standard file names11928
+Node: Other compiler13807
+Node: Other cross-reference14382
+Node: Other customization15105
+Node: Compiling Executing19096
+Node: Compile commands19819
+Node: Compiling Examples22511
+Node: No project files23343
+Node: Set compiler options28659
+Node: Set source search path30712
+Node: Use wisi project file32949
+Node: Use multiple GNAT project files36556
+Node: Use a Makefile41400
+Node: Compiler errors43051
+Node: Project files43868
+Node: Project file overview44920
+Node: Project file variables45462
+Node: Moving Through Ada Code48902
+Node: Identifier completion51934
+Node: Indentation52968
+Node: Statement skeletons56497
+Node: Aligning code58140
+Node: Automatic casing59085
+Node: Comment Handling61272
+Node: Key summary61791
+Node: Developer overview64521
+Node: Directory structure64850
+Node: ELPA67537
+Node: Savannah68174
+Node: ada-france68526
+Node: GNU Free Documentation License68765
End Tag Table
diff --git a/packages/ada-mode/ada-mode.texi b/packages/ada-mode/ada-mode.texi
index 718abbd..042236b 100644
--- a/packages/ada-mode/ada-mode.texi
+++ b/packages/ada-mode/ada-mode.texi
@@ -2,7 +2,7 @@
@settitle Ada Mode
@copying
-Copyright @copyright{} 1999 - 2019 Free Software Foundation, Inc.
+Copyright @copyright{} 1999 - 2020 Free Software Foundation, Inc.
@quotation
Permission is granted to copy, distribute and/or modify this document
@@ -25,7 +25,7 @@ developing GNU and promoting software freedom.''
@titlepage
@sp 10
-@title Ada Mode Version 6.2.1
+@title Ada Mode Version 7.0.1
@page
@vskip 0pt plus 1filll
@insertcopying
@@ -37,7 +37,7 @@ developing GNU and promoting software freedom.''
@node Top, Overview, (dir), (dir)
@top Top
-Ada Mode Version 6.2.1
+Ada Mode Version 7.0.1
@end ifnottex
@menu
@@ -56,7 +56,6 @@ Ada Mode Version 6.2.1
* Key summary::
* Developer overview::
* GNU Free Documentation License::
-* Index::
@detailmenu
--- The Detailed Node Listing ---
@@ -68,13 +67,12 @@ Overview
Installation
* Ada Reference Manual::
-* gpr_query::
-* process parser::
+* Ada executables::
-gpr_query
+Ada executables
* Building GNATCOLL 2019::
-* Building @file{gpr_query}::
+* Building the executables::
Customizing Ada mode
@@ -95,7 +93,7 @@ Compiling Examples
* No project files:: Just menus
* Set compiler options:: A basic Ada mode project file
* Set source search path:: Source in multiple directories
-* Use GNAT project file::
+* Use wisi project file::
* Use multiple GNAT project files::
* Use a Makefile::
@@ -107,18 +105,10 @@ Project files
Developer overview
* Directory structure::
-* Package organization::
* ELPA::
* Savannah::
* ada-france::
-Package organization
-
-* Ada mode::
-* gpr mode::
-* GNAT core::
-* Wisi::
-
@end detailmenu
@end menu
@@ -162,19 +152,30 @@ information on debugging.
@section Why not LSP?
The Language Server Protocol (LSP, @url{https://langserver.org})
supports an external language parser, as Ada mode does, and it is
-supported by the GNU ELPA package eglot. We do not use LSP, because it
-does not support indentation and fontification.
+supported by the GNU ELPA package eglot. Ada mode does not use LSP mostly for
+historical reasons; the Ada mode parser was first developed before LSP
+was started. In addition, LSP does not support some of the navigation
+information provided by the Ada mode parser (although that could be
+provided as a custom command).
+
+We may investigate supporting an LSP parser in the future. In
+particular, the AdaCore Gnat Studio editor uses an LSP parser for
+several functions; Emacs Ada mode could use that as a backend if it
+supports LSP.
@node Installation, Customization, Overview, Top
@chapter Installation
Ada mode requires Emacs 25.0 or greater. Compiling the Ada code for
the external process parser requires GNAT GPL 2017 or later; tested
-with GNAT Community Edition 2018 and GNAT Pro 19.
+with GNAT Community Edition 2019 and GNAT Pro 19.
Ada mode is distributed in the Gnu ELPA package archive; it can be
installed via @code{M-x list-packages} (@pxref{Packages,,,emacs,Emacs
-User Guide}). In Emacs < 27 you must first enable packages in your
+User Guide}). Note that it requires the @code{wisi} and
+@code{uniquify-files} packages as dependencies.
+
+In Emacs < 27 you must first enable packages in your
@file{~/.emacs}, @emph{after} customizing
@code{Info-default-directory-list} (if you do that):
@@ -182,31 +183,26 @@ User Guide}). In Emacs < 27 you must first enable
packages in your
(package-initialize)
@end example
-Ada mode is also available as a separate distribution, from the Emacs
-Ada mode website
-@uref{http://stephe-leake.org/emacs/ada-mode/emacs-ada-mode.html}.
-
-For installing the separate distribution, see the @file{README} file
-in the distribution.
-
To see what version of Ada mode you have installed, invoke @kbd{M-x
ada-mode-version}.
-You may also want to install additional utilities:
+You must also install the associated Ada executables (for the language
+parser). You may want to install the Ada Reference Manual.
@menu
* Ada Reference Manual::
-* gpr_query::
-* process parser::
+* Ada executables::
@end menu
-@node Ada Reference Manual, gpr_query, Installation, Installation
+@node Ada Reference Manual
@section Ada Reference Manual
The ELPA package ada-ref-man includes the Ada Reference Manual and
Annotated Ada Reference Manual in info format.
-@node gpr_query, , Ada Reference Manual, Installation
-@section gpr_query
+@node Ada executables
+@section Ada executables
+
+Ada mode requires the external parser, which must be compiled.
Ada mode has support for an external cross reference tool
@file{gpr_query}, which uses compiler-generated information. In the
@@ -219,14 +215,31 @@ not available in FSF GCC.
@file{gpr_query} is an Ada program, which is distributed as source and
must be built. Its source code is in the @code{ada-mode} Gnu ELPA package.
-@file{gpr_query} requires the @code{GNATCOLL} library provided by
-AdaCore, distributed with GNAT GPL 2017 or later, and also available
-at Github (@url{https://github.com/AdaCore/gnatcoll}). The notes below
-assume that the compiler is installed at @file{$prefix},
+@file{gpr_query} is similar to the AdaCore utility @code{gnatxref},
+but supports additional queries.
+
+Both the parser and @file{gpr_query} require the @code{GNATCOLL}
+library provided by AdaCore, distributed with GNAT GPL 2017 or later,
+and also available at Github
+(@url{https://github.com/AdaCore/gnatcoll}). The notes below assume
+that the compiler is installed at @file{$prefix},
e.g. @file{/usr/local/gnat-2019}, and that @file{$prefix/bin} is first
on the @code{PATH}. If you are running Windows, use mingw64
@code{bash} to run these commands.
+On linux, some versions of the @code{GNATCOLL.iconv} package (used by
+@code{gpr_query}, but not the parser) explicity
+require the @file{libiconv.so} library. GNAT provides the
+@file{libiconv.so} library in @file{<gnat>/lib64/libiconv.so}. On
+Debian, that directory is not in the standard load path, and iconv is
+provided by glibc, so @file{libiconv.so} is not found on the standard
+load path. So you must set @var{LD_LIBRARY_PATH}, but only when
+running @code{gpr-query}:
+
+@example
+(setq gpr-query-env '("LD_LIBRARY_PATH=/Projects/gnat/pro_19.2/lib64")
+@end example
+
In general, @file{gpr_query} should be compiled with the compiler
version that is used to generate the user project @file{.ali} files;
the @file{ali} file format can change with each compiler
@@ -240,7 +253,7 @@ does not include the xref package, which is required by
@menu
* Building GNATCOLL 2019::
-* Building @file{gpr_query}::
+* Building the executables::
@end menu
@node Building GNATCOLL 2019
@@ -263,28 +276,29 @@ make -C xref
make -C xref install
@end example
-@node Building @file{gpr_query}
-@subsection Building @file{gpr_query}
+@node Building the executables
+@subsection Building the executables
-To build and install @file{gpr_query}, assuming the
+@file{gpr_query} requires the @code{pthread} library. On Windows, this
+is available in Mingw64 as package
+@code{mingw64/mingw-w64-x86_64-winpthreads-git}.
+
+To build and install @file{gpr_query} and the parser, assuming the
@code{ada-mode-6.0.xx} GNU ELPA package is installed:
@example
cd ~/.emacs.d/elpa/ada-mode-6.0.xx
./build.sh
+./install.sh
@end example
-@code{ada-mode} will use @file{gpr_query} for cross reference
-functions if @file{gpr_query} is found in @code{PATH}.
-
-@node process parser, , ,
-@section process parser
-The process parser is built and installed by the same @code{build.sh}
-script as @xref{gpr_query}. ada-mode will automatically use it if it
-is available.
+By default, @file{install.sh} installs the executables in the same
+directory as the GNAT executable (using @file{gprinstall}). If you
+don't have write privileges there, or if you want to install somewhere
+else, use @code{install.sh --prefix=<dir>}.
-To override the automatic choice of parser, set @var{ada-parser} to
-either @code{'elisp} or @code{'parser}.
+@code{ada-mode} will use @file{gpr_query} and the parser if they are
+found in @code{PATH}.
@node Customization, Compiling Executing, Installation, Top
@chapter Customizing Ada mode
@@ -305,15 +319,15 @@ the tutorial (@kbd{C-h t}).
@node Slow response
@section Slow response
-In large files, parsing is slow, so it gets in the way of interactive
-typing due to immediate fontification triggering a parse.
+In large files, parsing takes a noticable amount of time, so it gets
+in the way of interactive typing due to immediate fontification
+triggering a parse.
There are three ways to deal with this:
@enumerate
-@item Install the process parser (@xref{process parser}), and set
-@code{wisi-partial-parse-threshold} appropriately in your
-@file{~./emacs}:
+@item Set @code{wisi-partial-parse-threshold}
+In your @file{~./emacs}:
@example
(setq wisi-partial-parse-threshold 100001)
@@ -323,17 +337,15 @@ The default value (100001) may already be appropriate; it
depends on
how fast your machine is, and what your tolerance for slow response
is.
-Files larger than @code{wisi-partial-parse-threshold} will be parsed
-partially; only the part of the buffer needed for the current task
-will be parsed. For fontification, that is the visible part. For indent,
-it is approximately the current subprogram or package. For navigation,
-it is always the entire file, which will still be slow; that is the
-only way to ensure useful results.
+Files larger than @code{wisi-partial-parse-threshold} (in characters)
+will be parsed partially; only the part of the buffer needed for the
+current task will be parsed. For fontification, that is the visible
+part. For indent, it is approximately the current subprogram or
+package. For navigation, it is always the entire file, which will
+still be slow; that is the only way to ensure useful results.
With this setting, indentation may not be correct; the Ada menu entry
-``Edit | Indent lines in file'' (or ``Edit | Indent current
-statement'', if point is on a keyword of a large enough enclosing
-statement) will parse the entire file and indent correctly.
+``Edit | Indent containing statement'' will indent correctly.
@item Delay fontification by setting @code{jit-lock-defer-time} in your
@file{~./emacs}:
@@ -371,7 +383,8 @@ corresponding spec and back.
Emacs and Ada mode support ways to use alternative file extensions for
specs and bodies. Note that you must also tell the compiler about
-these extensions; doing that is beyond the scope of this manual.
+these extensions in a GNAT project file Naming package; doing that is
+beyond the scope of this manual.
For instance, if your spec and bodies files are called
@file{@var{unit}_s.ada} and @file{@var{unit}_b.ada}, respectively, you
@@ -408,20 +421,20 @@ the scope of this manual; see the current definitions in
@node Other compiler, Other cross-reference, Non-standard file names,
Customization
@section Other compiler
-The project variable @code{ada_compiler} (default elisp variable
-@code{ada-compiler}) is used to index several variables that point to
-the compiler-specific functions for corresponding Ada mode operations.
+The wisi project variable @code{ada_compoiler} (default elisp variable
+@code{ada-compiler}) (default @code{'gnat}) controls dispatching in
+compiler-specific functions for corresponding Ada mode operations.
To use a compiler other than GNAT, you must write Emacs lisp code that
provides the interface to the compiler, and set @code{ada-compiler} and
the indirection variables.
-See @file{ada-gnat-compile.el} for an example.
+See @file{ada-compiler-gnat.el} for an example.
@node Other cross-reference, Other customization, Other compiler, Customization
@section Other cross-reference
-The project variable @code{ada_xref} (default elisp variable
-@code{ada-xref-tool}) is used to index several variables that point to
+The wisi project variable @code{xref_tool} (default elisp variable
+@code{ada-xref-tool}) controls dispatching in
the cross-reference-tool-specific functions for corresponding Ada mode
operations.
@@ -438,9 +451,9 @@ See @file{ada-gnat-xref.el} and @file{gpr-query.el} for
examples.
@node Other customization, , Other cross-reference, Customization
@section Other customization
-All user-settable Ada mode variables can be set via the menu
-@samp{Ada | Customize}. Click on the @samp{Help} button there for help
-on using customize.
+All user-settable Ada mode variables can be set via the menu @samp{Ada
+| Customize}; some can also be set in wisi project files
+(@pxref{Project files}).
To modify a specific variable, you can directly call the function
@code{customize-variable}; just type @kbd{M-x customize-variable
@@ -449,11 +462,13 @@ To modify a specific variable, you can directly call the
function
Alternately, you can specify variable settings in the Emacs
configuration file, @file{~/.emacs}. This file is coded in Emacs lisp,
and the syntax to set a variable is the following:
+
@example
(setq variable-name value)
@end example
Some general Emacs settings that are useful for Ada files:
+
@table @code
@item context menu
By default, the context menu is bound to @key{C-down-mouse-3},
@@ -466,6 +481,19 @@ Ada mode does not provide any @code{other-frame} or
recommended to use the Gnu ELPA package @code{other-frame-window}.
@item delete-trailing-whitespace
Deletes space, tab at end of line and blank lines at end of buffer.
+@item xref configuration
+@table @code
+@item xref-prompt-for-identifier
+Set to @code{nil} to be prompted less when finding definitions or
+references.
+@item xref-show-xrefs-function
+Determine placement of the window where references are shown.
+@item xref-show-definitions-function
+Determine placement of the window where definitions are shown.
+@item xref--transient-buffer-mode-map
+keymap used in some xref windows; you may want to disable the
+@key{RET} binding there.
+@end table
@item untabify
Deletes tab characters that have crept into the file.
@item indent-tabs-mode
@@ -476,12 +504,12 @@ year.
@item electric-pair-mode
Insert a matching right paren when you type a left paren.
@item hippie-expand
-Bind @code{hippie-expand} to a key; it expands the word before point, using
-words from current buffer, other buffers, file names, etc; see
+Bind @code{hippie-expand} to a key; it expands the word before point,
+using words from current buffer, other buffers, file names, etc; see
@code{hippie-expand-try-functions-list}. You can also add
-@code{ada-skel-hippie-try} to that list. Note that @code{ada-expand},
-which defaults to @code{ada-skel-expand}, is bound to @key{C-c C-e}
-(@pxref{Statement skeletons}).
+@code{wisi-skel-hippie-try} to that list. Note that
+@code{wisi-skel-expand} is bound to @key{C-c C-e} (@pxref{Statement
+skeletons}).
@item imenu
Navigate to subprograms and types by name, from a minibuffer menu.
@item speedbar
@@ -499,10 +527,15 @@ first.
@example
(setq-default indent-tabs-mode nil)
+(define-key xref--transient-buffer-mode-map (kbd "RET") 'xref-goto-xref)
+(setq xref-prompt-for-identifier nil) ;; only prompt on C-u
+(setq xref-show-xrefs-function #'xref--show-defs-buffer-at-bottom)
+(setq xref-show-definitions-function #'xref--show-defs-buffer-at-bottom)
+
(electric-pair-mode 1)
(require 'imenu) ;; also enables speedbar
(require 'ada-mode)
-(add-to-list 'hippie-expand-try-functions-list 'ada-skel-hippie-try)
+(add-to-list 'hippie-expand-try-functions-list 'wisi-skel-hippie-try)
(define-key ada-mode-map "\C-e" 'hippie-expand)
(define-key ada-mode-map [down-mouse-3] 'ada-popup-menu)
(add-hook 'ada-mode-hook
@@ -524,8 +557,8 @@ the GNAT compiler for simple projects (single files, or
several files
in a single directory).
For complex projects, you will want to use @code{make} or some other
-build tool; in that case, you will need an Emacs Ada mode project file
-to tell Emacs about the project directory tree and other settings.
+build tool; in that case, you may need a wisi project file to tell
+Emacs about the project directory tree and other settings.
@menu
* Compile commands::
@@ -537,7 +570,7 @@ to tell Emacs about the project directory tree and other
settings.
@section Compile commands
Here are the commands for building an Ada project and running the main
-program.
+program; they are all on the @code{Ada | Build} menu.
In multi-file projects, there must be one file that is the main
program. That is given by the @code{main} project file variable;
@@ -565,7 +598,7 @@ Sets @code{main} to the current file, then executes the
Build
command.
@item Show main
-Display @code{main} in the message buffer.
+Displays @code{main} in the message buffer.
@item Build
Compiles all obsolete units of the current @code{main}, and links
@@ -587,7 +620,7 @@ This command is not available for a cross-compilation
toolchain.
It is important when using these commands to understand how
@code{main} is used and changed.
-Build runs 'gnatmake' on the main unit. During a typical edit/compile
+Build runs 'gprbuild' on the main unit. During a typical edit/compile
session, this is the only command you need to invoke, which is why it
is bound to @kbd{C-c C-c}. It will compile all files needed by the
main unit, and display compilation errors in any of them.
@@ -630,7 +663,7 @@ website mentioned in @xref{Installation}.
* No project files:: Just menus
* Set compiler options:: A basic Ada mode project file
* Set source search path:: Source in multiple directories
-* Use GNAT project file::
+* Use wisi project file::
* Use multiple GNAT project files::
* Use a Makefile::
@end menu
@@ -644,14 +677,14 @@ First, create a directory @file{Example_1}, containing:
@file{hello.adb}:
@example
-with Ada.Text_IO;
+with Ada.Text_Io;
procedure Hello
is begin
Put_Line("Hello from hello.adb");
end Hello;
@end example
-Yes, this is missing ``use Ada.Text_IO;'' - we want to demonstrate
+Yes, this is missing ``use Ada.Text_Io;'' - we want to demonstrate
compiler error handling.
@file{hello_2.adb} has no errors:
@@ -675,19 +708,18 @@ end Hello_Pkg;
@file{hello_pkg.adb}:
@example
-with Ada.Text_IO;
+with Ada.Text_Io;
package Hello_Pkg is
procedure Say_Hello
is begin
- Ada.Text_IO.Put_Line ("Hello from hello_pkg.adb");
+ Ada.Text_Io.Put_Line ("Hello from hello_pkg.adb");
end Say_Hello;
end Hello_Pkg;
@end example
Yes, this is missing the keyword @code{body}; another compiler error
example. However, note that the indentation engine parser accepts this
-code with no errors, making it easier to indent slightly illegal Ada
-code.
+code, making it possible to indent illegal Ada code.
In buffer @file{hello.adb}, invoke the menu entry @samp{Ada | Build |
Check syntax}. You should get a @code{*compilation*} buffer containing
@@ -697,12 +729,14 @@ something like (the directory paths will be different):
-*- mode: compilation; default-directory:
"c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_1/" -*-
Compilation started at Fri Oct 18 04:23:54
-gnatmake -u -c -gnatc
c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_1/hello.adb -cargs
-gcc -c -Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_1/ -gnatc -I-
c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_1/hello.adb
+gprbuild -u -c -gnatc c:/Projects/org.emacs.ada-mode/test/Example_1/hello.adb
+using project file D:\Apps\GNAT-gpl_2019\share\gpr\_default.gpr
+Compile
+ [Ada] hello.adb
hello.adb:4:04: "Put_Line" is not visible
hello.adb:4:04: non-visible declaration at a-textio.ads:263
hello.adb:4:04: non-visible declaration at a-textio.ads:259
-gnatmake: "c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_1/hello.adb"
compilation error
+gprbuild: *** compilation phase failed
Compilation exited abnormally with code 4 at Fri Oct 18 04:23:54
@end example
@@ -712,9 +746,9 @@ highlighted, with the file name in red.
Now invoke @samp{Ada | Build | Next compilation error}. Or you can
click the middle mouse button on the first error line, or use the key
-binding shown on the menu. The compilation buffer scrolls to put the
-first error on the top line, and point is put at the place of the
-error in the @file{hello.adb} buffer.
+binding shown on the menu. In the compilation buffer, a triangle is
+placed in the left fringe on the first error line, and point is put at
+the place of the error in the @file{hello.adb} buffer.
To fix the error, invoke @samp{Ada | Build | Fix compilation error};
this adds ``Ada.Text_Io.'' to the line:
@@ -733,10 +767,15 @@ compilation buffer is displayed again, containing:
-*- mode: compilation; default-directory:
"c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_1/" -*-
Compilation started at Fri Oct 18 20:39:33
-gnatmake -o hello hello -cargs -bargs -largs
-gcc -c hello.adb
-gnatbind -x hello.ali
-gnatlink hello.ali -o hello.exe
+gprbuild hello
+using project file D:\Apps\GNAT-gpl_2019\share\gpr\_default.gpr
+Compile
+ [Ada] hello.adb
+Bind
+ [gprbind] hello.bexch
+ [Ada] hello.ali
+Link
+ [link] hello.adb
Compilation finished at Fri Oct 18 20:39:34
@end example
@@ -767,11 +806,10 @@ Build}. This finds an error in @file{hello_pkg.adb}:
hello_pkg.adb:2:08: keyword "body" expected here [see file name]
@end example
-This demonstrates that gnatmake finds the files needed by the main
+This demonstrates that gprbuild finds the files needed by the main
program. However, it cannot find files in a different directory,
-unless you use an Emacs Ada mode project file or a GNAT project file
-to specify the other directories; @xref{Set source search path},
-@ref{Use GNAT project file}.
+unless you use a GNAT project file to specify the other directories;
+@ref{Set source search path}.
Invoke @samp{Ada | Build | Show main}; this displays @file{Ada mode
main: hello_2}.
@@ -783,7 +821,7 @@ package body Hello_Pkg is
@end example
Now, while still in @file{hello_pkg.adb}, invoke @samp{Ada | Build |
-Build}. gnatmake successfully builds @file{hello_2}. This
+Build}. gprbuild successfully builds @file{hello_2}. This
demonstrates that Emacs has remembered the main file, in the project
variable @code{main}, and used it for the Build command.
@@ -812,7 +850,7 @@ specifies @code{main}.
@node Set compiler options, Set source search path, No project files,
Compiling Examples
@subsection Set compiler options
-This example illustrates using an Emacs Ada mode project file to set a
+This example illustrates using a gnat project file to set a
compiler option.
If you have files from @file{Example_1} open in Emacs, you should
@@ -824,7 +862,7 @@ In directory @file{Example_2}, create these files:
@file{hello.adb}:
@example
-with Ada.Text_IO;
+with Ada.Text_Io;
procedure Hello
is begin
Put_Line("Hello from hello.adb");
@@ -832,50 +870,53 @@ end Hello;
@end example
This is the same as @file{hello.adb} from @file{Example_1}. It has two
-errors; missing ``use Ada.Text_IO;'', and no space between
+errors; missing ``use Ada.Text_Io;'', and no space between
@code{Put_Line} and its argument list.
-@file{hello.adp}:
+@file{hello.gpr}:
@example
-comp_opt=-gnatyt
+project Hello is
+ package Compiler is
+ for Default_Switches ("Ada") use ("-gnatyt");
+ end Compiler;
+end Hello;
@end example
This tells the GNAT compiler to check for token spacing; in
particular, there must be a space preceding a parenthesis.
In buffer @file{hello.adb}, invoke @samp{Ada | Build | Set main and
-Build}. This finds the project file @file{hello.adp}, uses it to set
+Build}. This finds the project file @file{hello.gpr}, uses it to set
the compiler options, and builds the project. You should get a
@code{*compilation*} buffer containing something like (the directory
paths will be different):
@example
-cd c:/Examples/Example_2/
-gnatmake -o hello hello -g -cargs -gnatyt -bargs -largs
-gcc -c -g -gnatyt hello.adb
+gprbuild -Phello.gpr hello
+Compile
+ [Ada] hello.adb
hello.adb:4:04: "Put_Line" is not visible
-hello.adb:4:04: non-visible declaration at a-textio.ads:264
-hello.adb:4:04: non-visible declaration at a-textio.ads:260
+hello.adb:4:04: non-visible declaration at a-textio.ads:508
+hello.adb:4:04: non-visible declaration at a-textio.ads:498
hello.adb:4:12: (style) space required
-gnatmake: "hello.adb" compilation error
+gprbuild: *** compilation phase failed
@end example
Compare this to the compiler output in @ref{No project files}; the
-gnatmake option @code{-cargs} has been replaced by @code{-cargs
--gnaty}, and an additional error is reported in @file{hello.adb} on
-line 4. This shows that @file{hello.adp} is being used to set the
-compiler options.
+compiler-provided default gpr file has been replaced by
+@code{hello.gpr}, and an additional error is reported in
+@file{hello.adb} on line 4. This shows that @file{hello.gpr} is being
+used to set the compiler options.
-Fixing the error, linking and running the code proceed as in @ref{No
-project files}.
+Use @kbd{C-x`}, @kbd{C-c M-`} to fix the errors, then @samp{Ada |
+Build | Build} and @samp{Ada | Build | Run} to build and run.
-@node Set source search path, Use GNAT project file, Set compiler options,
Compiling Examples
+@node Set source search path
@subsection Set source search path
In this example, we show how to deal with files in more than one
-directory, using an Emacs Ada mode project file to set the search
-path.
+directory, setting the source search path in the gpr file.
Create the directory @file{Example_3}, containing:
@@ -890,11 +931,11 @@ end Hello_Pkg;
@file{hello_pkg.adb}:
@example
-with Ada.Text_IO;
+with Ada.Text_Io;
package Hello_Pkg is
procedure Say_Hello
is begin
- Ada.Text_IO.Put_Line ("Hello from hello_pkg.adb");
+ Ada.Text_Io.Put_Line ("Hello from hello_pkg.adb");
end Say_Hello;
end Hello_Pkg;
@end example
@@ -902,13 +943,21 @@ end Hello_Pkg;
These are the same files from example 1; @file{hello_pkg.adb} has an
error on line 2.
-In addition, create a directory @file{Example_3/Other}, containing these files:
+@file{other.gpr}:
+
+@example
+project Other is
+ for Source_Dirs use (".", "Other");
+end Other;
+@end example
+
+In addition, create a directory @file{Example_3/Other}, containing this file:
@file{Other/hello_3.adb}:
@example
with Hello_Pkg;
-with Ada.Text_IO; use Ada.Text_IO;
+with Ada.Text_Io; use Ada.Text_Io;
procedure Hello_3
is begin
Hello_Pkg.Say_Hello;
@@ -918,19 +967,11 @@ end Hello_3;
There are no errors in this file.
-@file{Other/other.adp}:
-
-@example
-src_dir=..
-@end example
-
-Note that there must be no trailing spaces.
-
In buffer @file{hello_3.adb}, invoke @samp{Ada | Project files | Find and
-set project...}, and select @file{Example_3/Other/other.adp}. This
+select project...}, and select @file{Example_3/other.gpr}. This
tells Emacs Ada mode to stop using the project file from
@file{Example_2}, and use the one for @file{Example_3}. Also note that
-since this project file is not named @file{hello_3.adp}, it would not
+since this project file is not named @file{hello_3.gpr}, it would not
be found by default.
Then, again in @file{hello_3.adb}, invoke @samp{Ada | Set main and
@@ -938,30 +979,34 @@ Build}. You should get a @code{*compilation*} buffer
containing
something like (the directory paths will be different):
@example
-cd c:/Examples/Example_3/Other/
-gnatmake -o hello_3 hello_3 -g -cargs -I.. -bargs -largs
-gcc -c -g -I.. hello_3.adb
-gcc -c -I./ -g -I.. -I- C:\Examples\Example_3\hello_pkg.adb
+gprbuild -Pother.gpr hello_3
+Compile
+ [Ada] hello_3.adb
+ [Ada] hello_pkg.adb
hello_pkg.adb:2:08: keyword "body" expected here [see file name]
-gnatmake: "C:\Examples\Example_3\hello_pkg.adb" compilation error
+gprbuild: "C:\Examples\Example_3\hello_pkg.adb" compilation error
@end example
-Compare the @code{-cargs} option to the compiler output in @ref{Set
-compiler options}; this shows that @file{other.adp} is being used to
-set the compiler options.
-
Move to the error with @kbd{C-x `}. Ada mode searches the list of
-directories given by @code{src_dir} for the file mentioned in the
+directories given by @code{Source_Dirs} for the file mentioned in the
compiler error message.
-Fixing the error, linking and running the code proceed as in @ref{No
-project files}.
+Use @kbd{C-x`}, @kbd{C-c M-`} to fix the errors, then @samp{Ada |
+Build | Build} and @samp{Ada | Build | Run} to build and run.
-@node Use GNAT project file, Use multiple GNAT project files, Set source
search path, Compiling Examples
-@subsection Use GNAT project file
+@node Use wisi project file, Use multiple GNAT project files, Set source
search path, Compiling Examples
+@subsection Use wisi project file
-In this example, we show how to use a GNAT project file, with no Ada
-mode project file.
+In this example, we show how to use a wisi project file to set some
+options that cannot be set in a gpr project file. In addition, we
+change a setting so you are prompted for a project file, rather than
+using a default one.
+
+Change the setting:
+
+@example
+M-x set-variable ada-build-prompt-prj search-prompt
+@end example
Create the directory @file{Example_4}, containing:
@@ -976,26 +1021,61 @@ end Hello_Pkg;
@file{hello_pkg.adb}:
@example
-with Ada.Text_IO;
-package Hello_Pkg is
+with Ada.Text_Io;
+package body Hello_Pkg is
procedure Say_Hello
is begin
- Ada.Text_IO.Put_Line ("Hello from hello_pkg.adb");
+ Put_Line ("Hello from hello_pkg.adb");
end Say_Hello;
end Hello_Pkg;
@end example
-These are the same files from example 1; @file{hello_pkg.adb} has an
-error on line 2.
+These two files are the similar to files from example 1;
+@file{hello_pkg.adb} has an error on line 5 (missing
+``Ada.Text_IO.'').
+
+@file{example_4.prj}:
+
+@example
+-- Wisi project file
-In addition, create a directory @file{Example_4/Gnat_Project},
+gpr_project_path=More
+
+gpr_file=example_4.gpr
+
+casing=example_4.casing
+@end example
+
+@file{example_4.prj} is a wisi project file; it specifies the
+@code{gpr_project_path}, telling @code{gprbuild} where to search for
+gpr files, and specifies the gpr file to use. Finally it specifies a
+casing exception file:
+
+@file{example_4.casing}:
+
+@example
+Text_IO
+@end example
+
+The default auto casing rules in ada-mode state that the Ada package
+``Ada.Text_IO'' should be capitalized as ``Ada.Text_Io'', which does
+not match the Ada Reference Manual. @file{example_4.casing} specifies
+that instead ``Text_IO'' should be capitalized as shown.
+
+You can create a casing exception by editing the file directly, or via
+the @code{Ada | Casing} menu.
+
+@code{gpr_project_path} and @code{casing} are list variables; each
+occurence in a wisi project file adds an entry to the list.
+
+In addition, create a directory @file{Example_4/More},
containing these files:
-@file{Gnat_Project/hello_4.adb}:
+@file{more/hello_4.adb}:
@example
with Hello_Pkg;
-with Ada.Text_IO; use Ada.Text_IO;
+with Ada.Text_Io; use Ada.Text_Io;
procedure Hello_4
is begin
Hello_Pkg.Say_Hello;
@@ -1003,50 +1083,60 @@ is begin
end Hello_4;
@end example
-There are no errors in this file.
+There are no errors in this file, except for the casing in ``Ada.Text_Io''.
-@file{Gnat_Project/hello_4.gpr}:
+@file{More/example_4.gpr}:
@example
-project Hello_4 is
+project Example_4 is
for Source_Dirs use (".", "..");
-end Hello_4;
+
+ package Compiler is
+ for Default_Switches ("Ada") use ("-gnatyknpr");
+ end Compiler;
+end Example_4;
@end example
-In buffer @file{hello_4.adb}, invoke @samp{Ada | Project | Load...}, and
-select @file{Example_4/Gnat_Project/hello_4.gpr}.
+The compiler switch checks all casing; we will get errors for ``Ada.Text_Io''.
-Then, again in @file{hello_4.adb}, invoke @samp{Ada | Set main and
-Build}. You should get a @code{*compilation*} buffer containing
+Then, in @file{hello_4.adb}, invoke @samp{Ada | Set main and
+Build}. ada-mode looks for a project file @file{hello_4.prj} or
+@file{hello_4.gpr}; since neither is found, you are prompted to find a
+project file. Select @file{Example_4/example_4.prj}; that is parsed
+and selected, and the build continues.
+
+You should get a @code{*compilation*} buffer containing
something like (the directory paths will be different):
@example
--*- mode: compilation; default-directory:
"c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4/Gnat_Project/" -*-
-Compilation started at Mon Oct 21 11:28:31
-
-gnatmake
-Pc:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4/Gnat_Project/hello_4.gpr
-o hello_4 hello_4 -cargs -I.
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4/Gnat_Project
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4
-Ic:/Apps/GNAT-7.1.2/lib/gcc/i686-pc-mingw32/4.7.3/adainclude -bargs -largs
-gcc -c -I.
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4/Gnat_Project
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4
-Ic:/Apps/GNAT-7.1.2/lib/gcc/i686-pc-mingw32/4.7.3/adainclude -I- -gnatA
C:\Projects\org.emacs.ada-mode.stephe-1\test\Example_4\hello_pkg.adb
-hello_pkg.adb:2:08: keyword "body" expected here [see file name]
-gnatmake:
"C:\Projects\org.emacs.ada-mode.stephe-1\test\Example_4\hello_pkg.adb"
compilation error
-
-Compilation exited abnormally with code 4 at Mon Oct 21 11:28:31
+gprbuild -Pexample_4.gpr hello_4
+Compile
+ [Ada] hello_pkg.adb
+hello_pkg.adb:1:16: (style) bad casing of "Text_IO" declared at a-textio.ads:57
+hello_pkg.adb:5:07: "Put_Line" is not visible
+hello_pkg.adb:5:07: non-visible declaration at a-textio.ads:508
+hello_pkg.adb:5:07: non-visible declaration at a-textio.ads:498
+gprbuild: *** compilation phase failed
@end example
-Compare the @code{gcc} options to the compiler output in @ref{Set
-compiler options}; this shows that @file{hello_4.gpr} is being used to
-set the compiler options.
+When you fix the errors, note that @kbd{C-c M-`} inserts the correct
+case for ``Ada.Text_IO'', and corrects the case where it is
+incorrect. The case is also corrected as you type; you can type
+``ada.text_io.'' and the case will be corrected when you type each
+``.'' or ``_''.
-Fixing the error, linking and running the code proceed as in @ref{No
-project files}.
-
-@node Use multiple GNAT project files, Use a Makefile, Use GNAT project file,
Compiling Examples
+@node Use multiple GNAT project files
@subsection Use multiple GNAT project files
In this example, we show how to use multiple GNAT project files,
-specifying the GNAT project search path in an Ada mode project file.
+specifying the GNAT project search path in an Ada mode project
+file. This also requires explicitly setting
+@code{project-find-functions}.
-Create the directory @file{Example_4} as specified in @ref{Use GNAT
-project file}.
+If you haven't already, create the directory @file{Example_4} as
+specified in @ref{Use wisi project file}. If you've already created it
+and run the tutorial, restore the compilation error in hello_pkg.adb;
+delete @code{Ada.Text_IO.} in front of @code{Put_Line}.
Create the directory @file{Example_5}, containing:
@@ -1064,58 +1154,116 @@ end Hello_5;
There are no errors in this file.
-@file{hello_5.adp}:
+@file{hello_5.prj}:
@example
-ada_project_path=../Example_4/Gnat_Project
+gpr_project_path=../Example_4/More
gpr_file=hello_5.gpr
+
+casing=../Example_4/example_4.casing
@end example
@file{hello_5.gpr}:
@example
-with "hello_4";
+with "example_4";
project Hello_5 is
for Source_Dirs use (".");
package Compiler is
- for Default_Switches ("Ada") use ("-g", "-gnatyt");
+ for Default_Switches ("Ada") use ("-g", "-gnatyknprt");
end Compiler;
end Hello_5;
@end example
In buffer @file{hello_5.adb}, invoke @samp{Ada | Project | Find and
-select project...}, and select @file{Example_5/hello_5.adp}. This
+select project...}, and select @file{Example_5/hello_5.prj}. This
would also be found by default if no previous project file had been
-selected.
+selected. Note that if @file{example_5.gpr} were named
+@file{hello_5.gpr}, the project file search would find more than one
+match, causing an error.
Then, again in @file{hello_5.adb}, invoke @samp{Ada | Build | Set main
and Build}. You should get a @code{*compilation*} buffer containing
something like (the directory paths will be different):
@example
--*- mode: compilation; default-directory:
"c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_5/" -*-
+-*- mode: compilation; default-directory:
"c:/Projects/org.emacs.ada-mode/test/Example_5/" -*-
Compilation started at Mon Oct 21 11:32:05
-gnatmake -Pc:/Projects/org.emacs.ada-mode.stephe-1/test/Example_5/hello_5.gpr
-o hello_5 hello_5 -cargs -I.
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_5
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4/Gnat_Project
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4
-Ic:/Apps/GNAT-7.1.2/lib/gcc/i686-pc-mingw32/4.7.3/adainclude -bargs -largs
-gcc -c -I. -Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_5
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4/Gnat_Project
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4
-Ic:/Apps/GNAT-7.1.2/lib/gcc/i686-pc-mingw32/4.7.3/adainclude -I- -gnatA
C:\Projects\org.emacs.ada-mode.stephe-1\test\Example_4\hello_pkg.adb
-hello_pkg.adb:2:08: keyword "body" expected here [see file name]
-gnatmake:
"C:\Projects\org.emacs.ada-mode.stephe-1\test\Example_4\hello_pkg.adb"
compilation error
-
-Compilation exited abnormally with code 4 at Mon Oct 21 11:32:05
+gprbuild -Pexample_5.gpr hello_5
+Compile
+ [Ada] hello_5.adb
+ [Ada] hello_pkg.adb
+hello_pkg.adb:5:07: "Put_Line" is not visible
+hello_pkg.adb:5:07: non-visible declaration at a-textio.ads:508
+hello_pkg.adb:5:07: non-visible declaration at a-textio.ads:498
+gprbuild: *** compilation phase failed
@end example
-Now type @kbd{C-x `}. @file{Example_4/hello_pkg.adb} is shown,
+Now type @kbd{C-x `}; @file{Example_4/hello_pkg.adb} is shown,
demonstrating that @file{hello_5.gpr} and @file{hello_4.gpr} are being
used to set the compilation search path.
+Now, in buffer @file{hello_pkg.adb} invoke the menu @code{Ada |
+Navigate | Find file in project} (which calls
+@code{ada-find-file}) to get back to the @file{hello_5.adb}
+buffer. If you have not selected any project files previously in this
+emacs session, this gives an unexpected prompt for a ``project
+directory''. Kill that with @kbd{C-g}. Otherwise, enter @kbd{hel <tab>
+5 <tab>}; it will say ``no match''.
+
+The problem here the way Emacs projects work. To find the current
+project, the functions in @code{project-find-functions} are run; one
+should return a project. The ada-mode build functions add
+@code{wisi-prj-find-dominating-cached} to
+@code{project-find-functions}; that looks in the current directory
+tree for a project file with the same name as one that was previously
+selected.
+
+If @file{Example_5} is the only project in the current emacs session,
+@code{wisi-prj-find-dominating-cached} finds no project file (because
+@file{Example_4} is not a child directory of @file{Example_5}, so the
+default strategy of ``ask the user'' is used, giving the prompt for a
+directory.
+
+If @file{Example_4} is also a project in the current emacs session,
+@code{wisi-prj-find-dominating-cached} finds that; since it does not
+contain @file{hello_5.adb}, @code{ada-find-file} cannot find it.
+
+Any time you have a main project that depends on other projects that
+are not in the same directory tree, you will have this problem.
+
+The fix is to use a different function in
+@code{project-find-functions}; @code{wisi-prj-current-cached}. This
+uses a global variable to indicate what the current project is. wisi
+provides four different functions for @code{project-find-functions}.
@xref{Selecting projects, Selecting projects, Selecting projects, wisi}.
+
+To change @code{project-find-functions}, execute:
+
+@example
+M-: (remove-hook 'project-find-functions 'wisi-prj-find-dominating-cached)
+M-: (add-hook 'project-find-functions 'wisi-prj-current-cached)
+@end example
+
+Normally, you must set @code{project-find-functions} in your
+@file{~/.emacs}, using the @code{add-hook} function. The ada-mode
+Build menu functions set it for you to make things simpler for
+novices, but they do not change it if you have put one of the wisi
+functions on it.
+
+Now set the current project; invoke @samp{Ada | Project | Find and
+select project...}, and select @file{Example_5/hello_5.prj}. Then in
+@file{hello_pkg.adb}, invoke @code{Ada |
+Navigate | Find file in project}; now we can find @file{hello_5.adb}.
+
@node Use a Makefile, , Use multiple GNAT project files, Compiling Examples
@subsection Use a Makefile
In this example, we show how to use a Makefile to build an Ada project
with GNAT, run the result, and clean the build directories.
-Create the directories @file{Example_4, Example_5} as specified in @ref{Use
GNAT
-project file}, @ref{Use multiple GNAT project files}.
+Create the directories @file{Example_4, Example_5} as specified in
+@ref{Use wisi project file}, @ref{Use multiple GNAT project files}.
In @file{Example_5}, add the file:
@@ -1129,31 +1277,38 @@ all : build run
.PHONY : force
build : force
- gprbuild -Phello_5.gpr hello_5
+ gprbuild -PExample_5.gpr hello_5
run :
./hello_5
clean :
- gnatclean -r -Phello_5
-
-export GPR_PROJECT_PATH = ../Example_4/Gnat_Project
+ gnatclean -r -PExample_5
# Local Variables:
-# eval:(ada-parse-prj-file "hello_5.adp")
-# eval:(ada-select-prj-file "hello_5.adp")
+# eval:(unless (wisi-prj-find-function-set-p)(add-hook 'project-find-functions
'wisi-prj-current-cached))
+# eval:(wisi-prj-dtrt-parse-file "hello_5.prj" (ada-prj-default "hello_5 #
main") "Makefile")
# End:
@end example
+Tell Emacs to allow @code{eval} in @code{Local Variables}:
+@example
+M-: (setq enable-local-eval t)
+@end example
+
Close and re-open @file{Makefile}; the @samp{Local Variables} section
-sets the project file to @file{hello_5.adp} when the @file{Makefile}
-is opened. You can also use @key{C-x C-e} to execute the select line
-after the @file{Makefile} is opened, to change the project file back
-to @file{hello_5.adp}.
+sets the project file to @file{hello_5.prj} when the @file{Makefile}
+is opened.
+
+If you have set @code{project-find-functions} in your @file{~/.emacs},
+you can leave out the first @code{eval} line. Note that
+@code{wisi-prj-dtrt-parse-file} does the right thing depending on
+which wisi function is in @code{project-find-functions}.
In @file{Makefile}, invoke @samp{Tools | Compile...}, and accept the
default make command. This runs the @samp{all} target, which builds
-@file{hello_5} and runs it.
+@file{hello_5} and runs it (you may have to fix source errors first,
+depending on how fresh the Example_4 directory is).
@node Compiler errors, , Compiling Examples, Compiling Executing
@section Compiler errors
@@ -1177,23 +1332,25 @@ references are accessed via @kbd{C-c `}.
@node Project files, Moving Through Ada Code, Compiling Executing, Top
@chapter Project files
-An Emacs Ada mode project file specifies what directories hold sources
-for your project, and allows you to customize the compilation commands
-and other things on a per-project basis.
+Ada mode uses wisi project files; @ref{wisi, Project files, Project files,
wisi}.
-The default file extension for Ada mode project files is @file{*.adp}
+A wisi project file specifies what directories hold sources for your
+project, and allows you to customize the compilation commands and
+other things on a per-project basis.
+
+The default file extension for wisi project files is @file{*.adp}
or @file{*.prj}. You can use a different extension by adding it to
@code{ada-prj-file-extensions}, and a different syntax by adding a
parser function to @code{ada-prj-parser-alist}.
-Note that Ada mode project files @file{*.adp} are different than GNAT
-compiler project files @samp{*.gpr}. However, Emacs Ada mode can use a
+Note that wisi project files are different than GNAT
+compiler project files (@samp{*.gpr}). However, Emacs Ada mode can use a
GNAT project file to specify the project directories. If no
other customization is needed, a GNAT project file can be used without
-an Emacs Ada mode project file.
+a wisi project file.
-If no Emacs Ada mode project file is specified, some Ada mode
-functions are not available.
+If no wisi project file is specified, some Ada mode functions are not
+available.
@menu
* Project file overview::
@@ -1203,171 +1360,110 @@ functions are not available.
@node Project file overview, Project file variables, Project files, Project
files
@section Project file overview
-Project files have a simple syntax; they may be edited directly. Each
-line specifies a project variable name and its value, separated by
-``='' (spaces not allowed):
-@example
-src_dir=/Projects/my_project/src_1
-src_dir=/Projects/my_project/src_2
-@end example
-
-Any line that does not have an ``='' is a comment.
-
-Some variables (like @code{src_dir}) are lists; multiple occurrences
-are concatenated.
-
-There must be no space between the variable name and ``='', and no
-trailing spaces after the value.
-
-The current project file is given by the lisp variable
-@code{ada-prj-default-project-file}, and shown by the menu command
+The current project file is shown by the menu command
@key{Ada | Project Files | Show project}.
-To set the project file, use the menu command @samp{Ada | Set Project
-...}, or the elisp functions @code{ada-parse-prj-file,
-ada-select-prj-file}. The latter can be added to a Makefile:
+To set the project file, use the menu command @key{Ada | Project Files | Find
and
+select Project ...}, or one of the elisp functions described in
+@ref{wisi, Selecting Projects, Selecting Projects, wisi}.
-@example
-# Local Variables:
-# eval: (ada-parse-prj-file "ada-mode.prj")
-# eval: (ada-select-prj-file ada-mode.prj")
-# End:
-@end example
-
-You specify either a GNAT project file or an Emacs Ada mode project
-file; if the file extension is @code{.gpr}, the file is treated as a
-GNAT project file. Extensions given by @code{ada-prj-file-extensions}
-(default @file{.adp, .prj}) are treated as an Emacs Ada mode
-project file.
-
-After a project file is parsed, you can make it current again with
-just @code{ada-select-prj-file}, or by selecting it from the menu.
+The project file may also be a GNAT project file (with file extension
+is @code{.gpr}).
@node Project file variables, , Project file overview, Project files
@section Project file variables
-To set a project variable that is a list, specify each element of the
-list on a separate line in the project file. The value on the last
-line is the last element in the list.
-
-A variable name that starts with @code{$} is set as a process
-environment variable, for processes launched from Emacs for the
-project.
-
-In variable values, process environment variables can be referenced
-using the normal @code{$var} syntax.
-
-Most project variables have defaults that can be changed by setting
+Some project variables have defaults that can be changed by setting
elisp variables; the table below identifies the elisp variable for each
project variable. Elisp variables corresponding to project variables
that are lists are elisp lists.
-In general, project variables are evaluated when referenced in Emacs
-Ada mode commands. Relative file paths are expanded relative to the
-directory containing the project file.
-
-Ada mode defines some project variables; others are defined by the
-compiler.
+wisi defines some project variables, Ada mode defines some, others are
+defined by the compiler and the cross reference tool.
-Here is the list of variables valid for all compilers. In the default
-values, the current directory @code{"."} is the directory containing
-the project file.
+Here is the list of variables valid defined by wisi and Ada mode. In
+the default values, the current directory @code{"."} is the directory
+containing the project file.
@table @asis
-@c These are the names that appear in the .adp file, which are the
-@c same as the symbols used with ada-prj-get
+@c These are the names that appear in the .prj file.
@c
-@c defined in ada-mode.el ada-prj-parse-file-1; alphabetical order
+@c defined in wisi-prj.el and ada-mode.el wisi-prj-parse-one.
@c defaults defined in ada-mode.el ada-prj-default
@item @code{ada_compiler} [default: @code{ada-compiler, gnat}]
-Ada compiler for this project. It must occur in the project file
-before any compiler-specific project variable.
+Ada compiler for this project.
-@item @code{auto_case} [default: @code{ada-auto-case, t}]
-Non-nil means automatically change case of preceding word while typing.
+Setting this in the project file reinitializes all options for the
+xref tool, so it must occur before any compiler-specific project
+variable.
-@item @code{case_identifier} [default: @code{ada-case-identifier,
mixed-case}]
-Indicates how to adjust the case of an Ada identifier.
+@item @code{casing}
+List of files containing casing exceptions. @xref{Automatic casing,
+Automatic casing, wisi.info}.
-@item @code{case_keyword} [default: @code{ada-case-keyword, lower-case}]
-Indicates how to adjust the case of an Ada keyword.
+@item @code{gnat-stub-args}
+List of strings passed to @code{gnat stub} when it is run.
-@item @code{case_strict} [default: @code{ada-case-strict, t}]
-If non-nil, @code{ada-mixed-case} forces @code{Mixed_Case} for identifiers.
-Otherwise, @code{ada-mixed-case} allows @code{UPPERCASE} for identifiers.
+@item @code{gnat-stub-cargs}
+List of strings passed to @code{gnat stub} after @code{-cargs}.
-@item @code{casing} [default: @code{ada-case-exception-file, nil}]
-List of files containing casing exceptions. @xref{Automatic casing}.
-
-@item @code{el_file} [default: ]
-The value is a file name, which is loaded as an elisp file when the
-project file is parsed or selected. This allows setting Ada mode indentation
-variables, and any arbitrary elisp code used to customize the project.
-
-@item @code{obj_dir} [default: @code{"."}]
+@item @code{obj_dir}
A list of directories to search for object and cross-reference
files. Only needed if you are not using GPR files.
-@item @code{path_sep} [default: @code{path-separator}]
-Separator character used in compiler search paths.
-
-@item @code{src_dir} [default: @code{"."}]
+@item @code{src_dir}
A list of directories to search for source files. Added to the source
-directories from a GPR file.
+directories from a gpr file (if any).
@item @code{xref_tool} [default: @code{ada-xref-tool}]
Cross reference tool for this project.
+Setting this in the project file reinitializes all options for the
+xref tool, so it must occur in the project file before any other
+settings that affect the xref tool.
+
If @file{gpr_query} is found in @code{PATH}, @code{ada-xref-tool}
defaults to @code{'gpr_query}. Otherwise, it defaults to @code{'gnat},
which uses @code{gnat find}.
@end table
-The following variables are valid with the GNAT compiler:
+The following project file variables are defined by the GNAT compiler:
@table @asis
-@item @code{ada_project_path} [default: @code{""}]
-@c ada-prj-get 'prj_dir, 'proc_env
-A list of directories to search for GNAT project files.
-
-If set, the @code{GPR_PROJECT_PATH} process environment variable is
-set to this value in the child process that runs GNAT tools. If not
-set, @code{GPR_PROJECT_PATH} in the child process is inherited from
-the Emacs process.
+@c defined in gnat-core.el wisi-compiler-parse-one.
+@item @code{ada_project_path} [default: ]
+Same as @code{gpr_project_path}; see below.
-If you have the @code{GPR_PROJECT_PATH} or @code{ADA_PROJECT_PATH}
-environment variable set in the Emacs process correctly for all of
-your projects, you do not need to set this project variable.
-
-The project search path can also be set in GNAT aggregate
-projects. However, the gnat tools do not make that path available to
-Emacs, so you must duplicate it in an Emacs Ada project file.
-
-@item @code{gpr_file} [default: @code{""}]
-The GNAT project file.
+@item @code{gpr_file} [default: ]
+The GNAT project file for the project.
If set, the source and project directories specified in the GNAT
project file are appended to @code{src_dir} and
-@code{ada_project_path}. This allows specifying Ada source directories
+@code{gpr_project_path}. This allows specifying Ada source directories
with a GNAT project file, and other source directories with the Emacs
project file.
-@item @code{gpr_project_path} [default: @code{""}]
-Same as @code{ada_project_path}.
+@item @code{gpr_project_path} [default: ]
+A list of directories to
+search for GNAT project files. The list is passed to tools via the
+@code{GPR_PROJECT_PATH} process environment variable in the process
+used to run the @code{gnat} and @code{gpr_query} tools.
+
+If not set, @code{GPR_PROJECT_PATH} in the child process is inherited
+from the Emacs process.
-@item @code{runtime} [default: @code{nil}]
-@c used in gnat-run-gnat
+@item @code{runtime} [default: ]
+@c slot gnat-compiler-runtime
If set, the name of the runtime, used as the value of the @code{RTS}
-command line option.
+command line option for tools.
@item @code{target} [default: @code{nil}]
-@c used in gnat-run-gnat, ada-gnat-xref-all
+@c slot gnat-compiler-target
If set, the name of the cross-compilation target, prepended to the
@code{gnat} executable name.
-
@end table
The following project variables are used by the @code{Ada | Build}
@@ -1400,29 +1496,33 @@ compiler, but others can be added (@pxref{Other
cross-reference}).
@table @kbd
@item C-c C-d
-@findex ada-goto-declaration
Move from any use of an identifier to its declaration, for from a declaration
to
its body (if there is one).
+This runs @code{xref-find-definitions}, which has a default global
+binding of @key{M-.}
+
@item C-c M-d
-@findex ada-goto-declaration-parent
Move from a child type declaration to the parent type declaration;
display a list of references if there is more than one parent.
@item C-c C-n
-@findex ada-next-statement-keyword
Move to the next keyword in the current statement.
For example, if point is on @samp{if}, move to @samp{then}.
+This runs @code{forward-sexp}, which has a default global binding of
+@kbd{C-M-f}.
+
@item C-c C-p
-@findex ada-prev-statement-keyword
Move to the previous keyword in the current statement.
For example, if point is on @samp{then}, move to @samp{if}.
+This runs @code{backward-sexp}, which has a default global binding of
+@kbd{C-M-b}.
+
@item C-c C-o
-@findex ada-find-other-file
Switch between corresponding spec and body. There are several special
cases:
@@ -1452,19 +1552,16 @@ corresponding declaration.
@end itemize
@item C-c C-r
-@findex ada-show-references
Show all references to the identifier surrounding point. Use
@kbd{C-x `} (@code{next-error}) to visit each reference (as for
compilation errors).
@item C-c C-x
-@findex ada-show-overriding
Show all declarations that override the primitive procedure at
point. Use @kbd{C-x `} (@code{next-error}) to visit each reference (as
for compilation errors).
@item C-c M-x
-@findex ada-show-overridden
Show the declaration that the declaration at point overrides.
@item C-u SPACE
@@ -1472,7 +1569,8 @@ Jump back to the previous location.
@item Ada | Misc | Refresh cross reference cache
Cross reference information is loaded from the compiler output when
-the first cross reference command is issued. If the code is recompiled
+the first cross reference command is issued (or when the project file
+is parsed, if useing cached project files). If the code is recompiled
after that, the cross reference information is reloaded by invoking
this menu command.
@@ -1486,6 +1584,9 @@ Emacs provides a general way of completing identifiers:
@kbd{M-/}
you just have to type the first few letters of an identifier, and then
loop through all the possible completions.
+If you have bound @code{hippie-expand}, that also uses
+@code{dabbrev-expand}.
+
@kbd{M-/} works by parsing all open Ada files for possible
completions.
@@ -1585,8 +1686,8 @@ Indentation for the lines in a @code{with} context clause.
@end table
The indentation variables are buffer local; the global value may be
-overridden in an elisp file invoked by an @code{el_file} Emacs Ada
-mode project file statement, or in a file local variable section.
+overridden in an elisp function on @code{ada-mode-hook}, or in a file
+local variable section.
The following keys indent portions of the text:
@table @kbd
@@ -1600,55 +1701,23 @@ Indent the current line, or the current region.
@item C-c TAB
Indent the current statement or declaration.
+@item C-c S-TAB
+Indent the statement or declaration containing the current statement
+or declaration.
+
@end table
The indentation algorithm relies on a grammar parser to identify the
-syntactic role for keywords and other words in the code. If the code
-is accepted by the parser, the indentation is done according to the
-rules in the indentation engine.
-
-If the code is not accepted (because it is partially complete during
-editing), the indentation engine falls back to the trivial algorithm
-of indenting each new line the same as the previous line. Once enough
-new text has been entered to make the code acceptable to the parser,
-the statement or declaration is properly indented.
-
-For example, if you are entering this code:
-
-@example
-if A then
- B;
-end if;
-@end example
-
-when you type @kbd{RET B}, @code{B} is indented to the same column as
-@code{if}, because the parser does not find @code{end if;}. Then when
-you type the final @code{;} followed by @key{TAB}, all three lines are
-indented, putting @code{B} where it belongs.
-
-To be more user friendly, the parser accepts a superset of the Ada
-grammer. For example, the parser accepts this code for an @code{if}
-statement:
-
-@example
-if then
-end if;
-@end example
-
-In general, any sequence of statements, and many expressions, may be
-omitted.
-
-One way to easily insert empty statements like this is using
-@ref{Statement skeletons}.
+syntactic role for keywords and other words in the code.
In rare cases, the parser gets confused; it can be reset by invoking
-menu @key{Ada | Misc | Reset parser}. Please report such cases as a
+menu @key{Ada | Misc | Restart parser}. Please report such cases as a
bug.
@node Statement skeletons, Aligning code, Indentation, Top
@chapter Statement skeletons
-@kbd{C-c C-e} expands the previous one or two words into a statment
+@kbd{C-c C-e} expands the previous one or two words into a statement
skeleton. For example, @kbd{i f C-c C-e} expands to:
@example
@@ -1658,10 +1727,6 @@ else
end if;
@end example
-All skeleton expansions are accepted by the indentation parser, so
-this is a convenient way to insert statements with correct
-indentation.
-
For named statements (packages, loops, etc), the name is taken from
the word before point, and the name of the statement from the word
before that.
@@ -1776,45 +1841,26 @@ all uppercase identifiers without defining a casing
exception.
@end table
You can define exceptions to these rules, in files specified by the
-variable @code{ada-case-exception-file}. Each line in a case exception
-file specifies the casing of one word or word fragment. If an
-exception is defined in multiple files, the first occurrence is used.
-
-If the word starts with an asterisk (@code{*}), it defines the casing
-of a word fragment (or ``substring''); part of a word between two
-underscores or word boundary.
-
-For example:
-
-@example
-DOD
-*IO
-GNAT
-@end example
-
-The word fragment @code{*IO} applies to any word containing ``_io'';
-@code{Text_IO}, @code{Hardware_IO}, etc.
+@code{casing} project variable; @ref{Casing exception files, Casing
+exception files, Casing exception files, wisi}.
-@findex ada-case-create-exception
-There are two ways to add new items to this file: you can simply edit
-it as you would edit any text file. Or you can position point on the
-word you want to add, and select menu @samp{Ada | Casing | Create full
-exception} or @samp{Ada | Casing | Create partial exception}. The
-word will be added to the current list of exceptions and to the file.
+There are two ways to add new items to a casing exception file: you
+can simply edit it as you would edit any text file, or you can
+position point on the word you want to add, and select menu @samp{Ada
+| Casing | Create full exception} or @samp{Ada | Casing | Create
+partial exception}. The word will be added to the current list of
+exceptions and to the file.
It is sometimes useful to have multiple exception files. For
example, one could be the standard Ada acronyms, the second some
company specific exceptions, and the last one some project specific
-exceptions. If you set up the variable @code{ada-case-exception-file}
-as a list of files, each of them will be parsed and used in your emacs
-session. When you create a new exception, you are prompted for the
+exceptions. When you create a new exception, you are prompted for the
file to save it in.
Other keys and menu entries are defined:
@table @kbd
@item C-c C-w
-@findex ada-case-adjust-at-point
Adjust case of the word at point. With prefix arg, adjust case even if
in a comment or string. Normally, comments and strings are not
affected by case adjust.
@@ -1835,7 +1881,6 @@ additional functions to handle comments:
@table @kbd
@item M-;
-@findex comment-dwim
If the region is active, comment or uncomment it.
If the current line is empty, start a comment.
@@ -1844,7 +1889,6 @@ Otherwise, add a comment at the end of the line, in a
column given by
@code{comment-column}.
@item M-q
-@findex fill-paragraph
Fill the current comment paragraph.
@end table
@@ -1882,6 +1926,10 @@ Indent the current line, or the current region.
@xref{Indentation}.
Indent the current statement or declaration.
+@item C-c S-TAB
+@xref{Indentation}.
+Indent the containing statement or declaration.
+
@item C-c `
@xref{Compiler errors}.
Move to the location of the secondary reference in the current compilation
error.
@@ -1962,13 +2010,12 @@ sources, here's an overview.
@menu
* Directory structure::
-* Package organization::
* ELPA::
* Savannah::
* ada-france::
@end menu
-@node Directory structure, Package organization, Developer overview, Developer
overview
+@node Directory structure
@section Directory structure
@table @file
@item org.emacs.ada-mode
@@ -2057,107 +2104,6 @@ More tests; allows testing path search features.
@end table
-@node Package organization
-@section Package organization
-
-@menu
-* Ada mode::
-* gpr mode::
-* GNAT core::
-* Wisi::
-@end menu
-
-@node Ada mode, gpr mode, Package organization, Package organization
-@subsection Ada mode
-Ada mode consists of all files with @file{ada-} prefix in the file
-name.
-
-@table @file
-@item ada-mode.el
-The main file, implementing the keymap, menu, and top level
-functionality.
-
-It allows for different backend implementations for compiling,
-cross-referencing, and indenting. The functions for each of these
-backends dispatch thru global variables that are set by Emacs Ada mode
-project files. They default to the GNAT compiler, the gnatxref cross
-reference tool, and the ada-wisi indentation engine.
-
-@item ada-build.el
-Provides functions for compiling Ada files without a Makefile (or
-similar tool).
-
-@item ada-fix-error.el
-Provides an interface to utilities for automatically fixing errors
-reported by the compiler. It dispatches to a compiler-specific
-backend.
-
-@item ada-gnat-compile.el
-Implements the Ada mode compiler functions for the GNAT compiler.
-
-@item ada-gnat-xref.el
-Implements the Ada mode cross reference functions for the GNAT compiler.
-
-@item ada.wy
-The Ada language grammar.
-
-@item ada-indent-user-options.el
-All user-settable options for the Ada indentation engine.
-
-@item ada-mode-compat.el
-Defines functions used by Ada mode that are not in older versions of Emacs.
-
-@item ada-mode.texi
-This Ada mode user guide source.
-
-@item ada-skel.el
-Skeletons for expansion of Ada syntax (@pxref{Statement
-skeletons}). Extends the Emacs skeleton functions with ``tokens'',
-inspired by the lamented Else package (which was inspired by DEC LSE).
-
-@item ada-wisi.el
-Implements the Ada mode indentation functions for the wisi indentation
-engine backend.
-
-@end table
-
-@node gpr mode, GNAT core, Ada mode, Package organization
-@subsection gpr mode
-
-gpr mode consists of all files with @file{gpr-} prefix in the file
-name. The functions in each file are similar to the similarly-named
-Ada mode files.
-
-@node GNAT core, Wisi, gpr mode, Package organization
-@subsection GNAT core
-@table @file
-
-@item gnat-core.el
-GNAT is actually a multi-language tool; it builds on top of the
-multi-language gcc.
-
-@file{gnat-core.el} is a start at a language-agnostic interface to the
-GNAT tools. It was first factored out from @file{ada-gnat.el} and
-@file{ada-mode.el} to support the multi-language @file{gpr_query.el}.
-
-More code currently in @file{ada-mode.el} could be migrated to
-@file{gnat-core.el}, in particular the project file support.
-
-@item gpr-query.el
-Provides an interface to the external multi-language cross-reference
-tool @file{gpr_query}.
-
-Implements the Ada mode cross-reference functions for the
-@file{gpr_query} backend, and a minor mode providing similar
-functions for C++.
-
-@end table
-
-@node Wisi, , GNAT core, Package organization
-@subsection Wisi
-
-The ``wisi'' parser. @xref{Overview, Overview, Overview, wisi}.
-
@node ELPA
@section ELPA
Ada mode is published via the Gnu ELPA archive. To test a new version
@@ -2193,13 +2139,8 @@ project admin page there for more information.
The source code for ada-mode is maintained in a monotone repository in
the ada-france server @url{mtn://www.ada-france.org}.
-@node GNU Free Documentation License, Index, Developer overview, Top
+@node GNU Free Documentation License
@appendix GNU Free Documentation License
@include doclicense.texi
-@node Index, , GNU Free Documentation License, Top
-@unnumbered Index
-
-@printindex fn
-
@bye
diff --git a/packages/ada-mode/ada-prj.el b/packages/ada-mode/ada-prj.el
deleted file mode 100644
index 819c970..0000000
--- a/packages/ada-mode/ada-prj.el
+++ /dev/null
@@ -1,4 +0,0 @@
-;;; ada-prj.el --- Dummy file to hide obsolete bundled version -*-
lexical-binding:t -*-
-(require 'ada-mode)
-(provide 'ada-prj)
-(message "'ada-prj' is obsolete; use 'ada-mode' instead")
diff --git a/packages/ada-mode/ada-process.el b/packages/ada-mode/ada-process.el
index 7c4ec40..73d3efa 100644
--- a/packages/ada-mode/ada-process.el
+++ b/packages/ada-mode/ada-process.el
@@ -98,6 +98,7 @@
LEFT_PAREN
RIGHT_PAREN
AMPERSAND
+ AT_SIGN
BAR
BOX
COLON
@@ -440,6 +441,7 @@
(LEFT_PAREN . "(")
(RIGHT_PAREN . ")")
(AMPERSAND . "&")
+ (AT_SIGN . "@")
(BAR . "|")
(BOX . "<>")
(COLON . ":")
diff --git a/packages/ada-mode/ada-project.el b/packages/ada-mode/ada-project.el
deleted file mode 100644
index ae5b3a4..0000000
--- a/packages/ada-mode/ada-project.el
+++ /dev/null
@@ -1,120 +0,0 @@
-;; ada-project.el - project.el backend for ada-mode projects -*-
lexical-binding: t -*-
-;;
-;; Copyright (C) 2017 - 2019 Free Software Foundation, Inc.
-;;
-;; Author: Stephen Leake <address@hidden>
-;;
-;; This file is part of GNU Emacs.
-;;
-;; GNU Emacs is free software: you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-;;
-;; GNU Emacs is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-;; GNU General Public License for more details.
-;;
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
-
-(require 'ada-mode)
-(require 'cl-lib)
-(require 'cl-generic)
-(require 'project)
-(require 'uniquify-files)
-
-(cl-defgeneric project-refresh (prj full)
- "Refresh all cached data in PRJ.
-If FULL is non-nil, very slow refresh operations may be skipped.")
-
-(defun refresh-project (full)
- "Refresh all cached data in the current project.
-With prefix arg, very slow refresh operations may be skipped."
- (interactive "P")
- (project-refresh (project-current) full))
-
-(cl-defgeneric project-select (prj)
- "User has selected PRJ as the active project; take actions to make that so."
- (setq compilation-search-path
- (append (project-roots prj)
- (project-external-roots prj)))
- )
-
-(cl-defgeneric project-deselect (_prj)
- "PRJ is the current project; user has selected another project.
-Undo actions done in `project-select'."
- (setq compilation-search-path nil)
- )
-
-(cl-defstruct (ada-project
- (:constructor nil) ;; no default
- (:constructor make-ada-project
- (&key
- env-vars
- ada-prj-file
- file-pred
- &aux
- (ada-prj (expand-file-name ada-prj-file))))
- )
- env-vars ;; a list of (NAME . VALUE)
- ada-prj ;; The ada-mode project file name (absolute).
-
- file-pred ;; Function taking an absolute file name, returns non-nil
- ;; if the file should be included in `project-files'.
- )
-
-(defvar ada-project-current nil
- "The current Ada project; an `ada-project' object.")
-
-;;;###autoload
-(defun ada-project-current (_dir)
- "Return the project the user has set in `ada-project-current'.
-For `project-find-functions'."
- ada-project-current)
-
-(cl-defmethod project-id ((prj ada-project))
- ;; project-id is experimental
- (ada-project-ada-prj prj))
-
-(cl-defmethod project-roots ((_prj ada-project))
- ;; Not meaningful
- nil)
-
-(cl-defmethod project-files ((prj ada-project) &optional dirs)
- (let (result)
- (dolist (dir (or dirs (ada-prj-get 'src_dir)))
- (mapc
- (lambda (absfile)
- (when (and (not (string-equal "." (substring absfile -1)))
- (not (string-equal ".." (substring absfile -2)))
- (not (file-directory-p absfile))
- (or (null (ada-project-file-pred prj))
- (funcall (ada-project-file-pred prj) absfile)))
- (push absfile result)))
- (directory-files dir t)))
- result))
-
-(when (not (fboundp 'project--read-file-cpd-relative)) ;; emacs < 27
- (cl-defmethod project-file-completion-table ((prj ada-project) &optional
dirs)
- (apply-partially #'uniq-file-completion-table (uniq-file-uniquify
(project-files prj dirs)))))
-
-(cl-defmethod project-select ((prj ada-project))
- (dolist (pair (ada-project-env-vars prj))
- (setenv (car pair) (cdr pair)))
- (ada-select-prj-file (ada-project-ada-prj prj)))
-
-(cl-defmethod project-deselect :before ((prj ada-project))
- (ada-deselect-prj (ada-project-ada-prj prj))
- (dolist (pair (ada-project-env-vars prj))
- (setenv (car pair) nil)))
-
-(cl-defmethod project-refresh ((_prj ada-project) full)
- ;; assume prj is current
- (ada-refresh-prj-file)
- (ada-xref-refresh full))
-
-(provide 'ada-project)
-
-;; end of file
diff --git a/packages/ada-mode/ada-skel.el b/packages/ada-mode/ada-skel.el
index c5218fa..3e54bdf 100644
--- a/packages/ada-mode/ada-skel.el
+++ b/packages/ada-mode/ada-skel.el
@@ -21,7 +21,7 @@
;;; Design:
;;
-;; The primary user command is `ada-skel-expand', which inserts the
+;; The primary user command is `wisi-skel-expand', which inserts the
;; skeleton associated with the previous word (possibly skipping a
;; name).
;;
@@ -29,8 +29,8 @@
;; is easier just to type in the buffer.
;;
;; These skeletons are not intended to teach a novice the language,
-;; just to make it easier to write code that the ada-wisi parser
-;; likes, and handle repeated names nicely.
+;; just to make it easier to write code that the wisi parser
+;; handles without error, and handle repeated names nicely.
;;; History:
@@ -63,7 +63,8 @@
;; skeletons; just make it easier to work with the ada-wisi parser,
;; don't try to teach syntax.
-(require 'skeleton nil t)
+(require 'skeleton)
+(require 'wisi-skel)
;;;;; user variables, example skeletons intended to be overwritten
@@ -123,10 +124,6 @@ This could end in a token recognized by `ada-skel-expand'."
)
-;; override ada-mode 4.01 autoloaded functions
-(define-obsolete-function-alias 'ada-header 'ada-skel-header "24.4"
- "Insert a descriptive header at the top of the file.")
-
;;;;; Ada skeletons (alphabetical)
(define-skeleton ada-skel-accept
@@ -309,7 +306,7 @@ See `ada-find-other-file' to create library level package
body from spec."
()
"with " str "; use " str ";")
-;;;;; token alist, other functions
+;;;;; token alist
(defconst ada-skel-token-alist
'(("accept" . ada-skel-accept)
@@ -351,138 +348,18 @@ See `ada-find-other-file' to create library level
package body from spec."
("spec" . ada-skel-task-spec))
("while" . ada-skel-while)
("with" . ada-skel-with-use))
- "alist of elements (STRING ELEMENT). See `ada-skel-expand'.
-STRING must be a symbol in the current syntax, and is normally
-the first Ada keyword in the skeleton. All strings must be
-lowercase; `ada-skel-expand' converts user inputs.
-
-ELEMENT may be:
-- a skeleton, which is inserted
-- an alist of (string . skeleton). User is prompted with `completing-read',
selected skeleton is inserted. ")
-
-(defvar ada-skel-test-input nil
- "When non-nil, bypasses prompt in alist token expansions - used for unit
testing.")
-
-(defun ada-skel-build-prompt (alist count)
- "Build a prompt from the keys of the ALIST.
-The prompt consists of the first COUNT keys from the alist, separated by `|',
with
-trailing `...' if there are more keys."
- (if (>= count (length alist))
- (concat (mapconcat 'car alist " | ") " : ")
- (let ((alist-1 (butlast alist (- (length alist) count))))
- (concat (mapconcat 'car alist-1 " | ") " | ... : "))
- ))
-
-(defun ada-skel-expand (&optional name)
- "Expand the token or placeholder before point to a skeleton, as defined by
`ada-skel-token-alist'.
-A token is a symbol in the current syntax.
-A placeholder is a symbol enclosed in generic comment delimiters.
-If the word before point is not in `ada-skel-token-alist', assume
-it is a name, and use the word before that as the token."
- (interactive "*")
-
- ;; Skip trailing space, newline, and placeholder delimiter.
- ;; Standard comment end included for languages where that is newline.
- (skip-syntax-backward " !>")
-
- ;; include punctuation here, in case is is an identifier, to allow
Ada.Text_IO
- (let* ((end (prog1 (point) (skip-syntax-backward "w_.")))
- (token (downcase (buffer-substring-no-properties (point) end)))
- (skel (assoc-string token ada-skel-token-alist))
- (handled nil))
-
- (if skel
- (progn
- (when (listp (cdr skel))
- (let* ((alist (cdr skel))
- (prompt (ada-skel-build-prompt alist 4)))
- (setq skel (assoc-string
- (or ada-skel-test-input
- (completing-read prompt alist))
- alist))
- (setq ada-skel-test-input nil) ;; don't reuse input on recursive
call
- ))
-
- ;; delete placeholder delimiters around token, token, and
- ;; name. point is currently before token.
- (skip-syntax-backward "!")
- (delete-region
- (point)
- (progn
- (skip-syntax-forward "!w_")
- (when name
- (skip-syntax-forward " ")
- (skip-syntax-forward "w_."))
- (point)))
- (funcall (cdr skel) name)
- (setq handled t))
-
- ;; word in point .. end is not a token; assume it is a name
- (when (not name)
- ;; avoid infinite recursion
-
- ;; Do this now, because skeleton insert won't.
- ;;
- ;; We didn't do it above, because we don't want to adjust case
- ;; on tokens and placeholders.
- (save-excursion (ada-case-adjust-region (point) end))
- (setq token (buffer-substring-no-properties (point) end))
-
- (ada-skel-expand token)
- (setq handled t)))
-
- (when (not handled)
- (error "undefined skeleton token: %s" name))
- ))
-
-(defun ada-skel-hippie-try (old)
- "For `hippie-expand-try-functions-list'. OLD is ignored."
- (if old
- ;; hippie is asking us to try the "next" completion; we don't have one
- nil
- (let ((pos (point))
- (undo-len (if (eq 't pending-undo-list)
- 0
- (length pending-undo-list))))
- (undo-boundary)
- (condition-case nil
- (progn
- (ada-skel-expand)
- t)
- (error
- ;; undo hook action if any
- (unless (or (eq 't pending-undo-list)
- (= undo-len (length pending-undo-list)))
- (undo))
-
- ;; undo motion
- (goto-char pos)
- nil)))))
-
-(defun ada-skel-next-placeholder ()
- "Move point to after next placeholder."
- (skip-syntax-forward "^!")
- (skip-syntax-forward "w!"))
-
-(defun ada-skel-prev-placeholder ()
- "Move point to after previous placeholder."
- (skip-syntax-backward "^!"))
+ "Ada tokens for `wisi-skel-token-alist', used by `wisi-skel-expand'.")
(defun ada-skel-setup ()
"Setup a buffer for ada-skel."
- (add-hook 'skeleton-end-hook 'ada-indent-statement nil t)
+ (setq wisi-skel-token-alist ada-skel-token-alist)
+ (add-hook 'skeleton-end-hook 'wisi-indent-statement nil t)
(when (and ada-skel-initial-string
(= (buffer-size) 0))
(insert ada-skel-initial-string))
)
-(provide 'ada-skeletons)
-(provide 'ada-skel)
-
-(setq ada-expand #'ada-skel-expand)
-(setq ada-next-placeholder #'ada-skel-next-placeholder)
-(setq ada-prev-placeholder #'ada-skel-prev-placeholder)
-
(add-hook 'ada-mode-hook #'ada-skel-setup)
+(provide 'ada-skel)
;;; ada-skel.el ends here
diff --git a/packages/ada-mode/ada-stmt.el b/packages/ada-mode/ada-stmt.el
deleted file mode 100644
index 3f5ed24..0000000
--- a/packages/ada-mode/ada-stmt.el
+++ /dev/null
@@ -1,4 +0,0 @@
-;;; ada-stmt.el --- Dummy file to hide obsolete bundled version -*-
lexical-binding:t -*-
-(require 'ada-mode)
-(provide 'ada-stmt)
-(message "'ada-stmt' is obsolete; use 'ada-mode' instead")
diff --git a/packages/ada-mode/ada-wisi.el b/packages/ada-mode/ada-wisi.el
deleted file mode 100644
index e257af2..0000000
--- a/packages/ada-mode/ada-wisi.el
+++ /dev/null
@@ -1,795 +0,0 @@
-;;; ada-wisi.el --- Indentation engine for Ada mode, using the wisi
generalized LALR parser -*- lexical-binding:t -*-
-;;
-;; [1] ISO/IEC 8652:2012(E); Ada 2012 reference manual
-;;
-;; Copyright (C) 2012 - 2019 Free Software Foundation, Inc.
-;;
-;; Author: Stephen Leake <address@hidden>
-;;
-;; This file is part of GNU Emacs.
-;;
-;; GNU Emacs is free software: you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-;;
-;; GNU Emacs is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-;; GNU General Public License for more details.
-;;
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
-;;
-;;;;
-
-(require 'ada-fix-error)
-(require 'ada-indent-user-options)
-(require 'ada-process)
-(require 'cl-lib)
-(require 'wisi)
-(require 'wisi-process-parse)
-
-(defconst ada-wisi-language-protocol-version "2"
- "Defines language-specific parser parameters.
-Must match wisi-ada.ads Language_Protocol_Version.")
-
-;; Refactor actions; must match wisi-ada.adb Refactor
-(defconst ada-refactor-method-object-to-object-method 1)
-(defconst ada-refactor-object-method-to-method-object 2)
-
-(defconst ada-refactor-element-object-to-object-index 3)
-(defconst ada-refactor-object-index-to-element-object 4)
-
-(defconst ada-refactor-format-paramlist 5)
-
-(defun ada-wisi-comment-gnat (indent after)
- "Modify INDENT to match gnat rules. Return new indent.
-INDENT must be indent computed by the normal indentation
-algorithm. AFTER indicates what is on the previous line; one of:
-
-code: blank line, or code with no trailing comment
-code-comment: code with trailing comment
-comment: comment"
- (let (prev-indent next-indent)
- ;; the gnat comment indent style check; comments must
- ;; be aligned to one of:
- ;;
- ;; - multiple of ada-indent
- ;; - next non-blank line
- ;; - previous non-blank line
- ;;
- ;; Note that we must indent the prev and next lines, in case
- ;; they are not currently correct.
- (cond
- ((and (not (eq after 'comment))
- (= 0 (% indent ada-indent)))
- ;; this will handle comments at bob and eob, so we don't
- ;; need to worry about those positions in the next checks.
- indent)
-
- ((and (setq prev-indent
- (if (eq after 'comment)
- (progn (forward-comment -1) (current-column))
- (save-excursion (forward-line -1)(current-indentation))))
- (= indent prev-indent))
- indent)
-
- ((and (setq next-indent
- ;; we use forward-comment here, instead of
- ;; forward-line, because consecutive comment
- ;; lines are indented to the current one, which
- ;; we don't know yet.
- (save-excursion (forward-comment
(point-max))(current-indentation)))
- (= indent next-indent))
- indent)
-
- (t
- (cl-ecase after
- (code-comment
- ;; After comment that follows code on the same line
- ;; test/ada_mode-conditional_expressions.adb
- ;;
- ;; then 44 -- comment matching GNAT
- ;; -- second line
- ;;
- ;; else 45)); -- comment _not_ matching GNAT style check
- ;; -- comment matching GNAT
- ;;
- (+ indent (- ada-indent (% indent ada-indent))))
-
- ((code comment)
- ;; After code with no trailing comment, or after comment
- ;; test/ada_mode-conditional_expressions.adb
- ;; (if J > 42
- ;; -- comment indent matching GNAT style check
- ;; -- second line of comment
- prev-indent)
-
- ))
- )))
-
-(defun ada-wisi-comment ()
- "Modify indentation of a comment:
-For `wisi-indent-calculate-functions'.
-- align to previous comment after code.
-- respect `ada-indent-comment-gnat'."
- ;; We know we are at the first token on a line. We check for comment
- ;; syntax, not comment-start, to accomodate gnatprep, skeleton
- ;; placeholders, etc.
- ;;
- ;; The normal indentation algorithm has already indented the
- ;; comment.
- (when (and (not (eobp))
- (= 11 (syntax-class (syntax-after (point)))))
-
- ;; We are looking at a comment; check for preceding comments, code
- (let (after
- (indent (current-column)))
- (if (save-excursion (forward-line -1) (looking-at "\\s *$"))
- ;; after blank line
- (setq after 'code)
-
- (save-excursion
- (forward-comment -1)
- (if (or (not ada-indent-after-trailing-comment) ;; ignore comment on
previous line
- (looking-at "\\s *$")) ;; no comment on
previous line
- (setq after 'code)
-
- (setq indent (current-column))
- (if (not (= indent (progn (back-to-indentation) (current-column))))
- ;; previous line has comment following code
- (setq after 'code-comment)
- ;; previous line has plain comment
- (setq indent (current-column))
- (setq after 'comment)
- )))
- )
-
- (cl-ecase after
- (code
- (if ada-indent-comment-gnat
- (ada-wisi-comment-gnat indent 'code)
- indent))
-
- (comment
- indent)
-
- (code-comment
- (if ada-indent-comment-gnat
- (ada-wisi-comment-gnat indent 'code-comment)
-
- ;; After comment that follows code on the same line
- ;; test/ada_mode-nominal.adb
- ;;
- ;; begin -- 2
- ;; --EMACSCMD:(progn
(ada-goto-declarative-region-start)(looking-at "Bad_Thing"))
- (save-excursion (forward-comment -1)(current-column)))
- ))
- )))
-
-(defun ada-wisi-post-parse-fail ()
- "For `wisi-post-parse-fail-hook'."
- ;; Parse indent succeeded, so we assume parse navigate will as well
- (wisi-validate-cache (point-min) (line-end-position) nil 'navigate)
- (save-excursion
- (let ((start-cache (wisi-goto-start (or (wisi-get-cache (point))
(wisi-backward-cache)))))
- (when start-cache
- ;; nil when in a comment at point-min
- (indent-region (point) (wisi-cache-end start-cache)))
- ))
- (back-to-indentation))
-
-;;;; ada-mode functions (alphabetical)
-
-(defun ada-wisi-declarative-region-start-p (cache)
- "Return t if cache is a keyword starting a declarative region."
- (memq (wisi-cache-token cache) '(DECLARE IS PRIVATE))
- ;; IS has a cache only if start of declarative region
- )
-
-(defun ada-wisi-context-clause ()
- "For `ada-fix-context-clause'."
- (wisi-validate-cache (point-min) (point-max) t 'navigate)
- (save-excursion
- (goto-char (point-min))
- (let ((begin nil)
- (end nil)
- cache)
-
- (while (not end)
- (setq cache (wisi-forward-cache))
- (cl-case (wisi-cache-nonterm cache)
- (pragma_g (wisi-goto-end-1 cache))
- (use_clause (wisi-goto-end-1 cache))
- (with_clause
- (when (not begin)
- (setq begin (line-beginning-position)))
- (wisi-goto-end-1 cache))
- (t
- ;; start of compilation unit
- (setq end (line-beginning-position))
- (unless begin
- (setq begin end)))
- ))
- (cons begin end)
- )))
-
-(defun ada-wisi-fix-error (_msg source-buffer _source-window)
- "For ’ada-fix-error-hook’. Calls ’wisi-repair-error’ if appropriate."
- (when (equal compilation-last-buffer wisi-error-buffer)
- (set-buffer source-buffer)
- (wisi-repair-error)
- t))
-
-(defun ada-wisi-on-context-clause ()
- "For `ada-on-context-clause'."
- (let (cache)
- (save-excursion
- ;; Don't require parse of large file just for ada-find-other-file
- (and (< (point-max) wisi-size-threshold)
- (setq cache (wisi-goto-statement-start))
- (memq (wisi-cache-nonterm cache) '(use_clause with_clause))
- ))))
-
-(defun ada-wisi-in-case-expression ()
- "For `ada-in-case-expression'."
- (save-excursion
- ;; Used by ada-align; we know we are in a paren.
- (ada-goto-open-paren 1)
- (while (forward-comment 1))
- (looking-at "case")))
-
-(defun ada-wisi-goto-subunit-name ()
- "For `ada-goto-subunit-name'."
- (wisi-validate-cache (point-min) (point-max) t 'navigate)
-
- (let (cache
- (name-pos nil))
- (save-excursion
- ;; move to top declaration
- (goto-char (point-min))
- (setq cache (or (wisi-get-cache (point))
- (wisi-forward-cache)))
-
- (when (eq (wisi-cache-nonterm cache) 'subunit)
- (setq name-pos (car (wisi-next-name-region))))
- )
- (when name-pos
- (goto-char name-pos))
- ))
-
-(defun ada-wisi-goto-declaration-start (&optional include-type)
- "For `ada-goto-declaration-start', which see.
-Also return cache at start."
- (wisi-validate-cache (point-min) (point-max) t 'navigate)
- (ada-wisi-goto-declaration-start-1 include-type))
-
-(defun ada-wisi-goto-declaration-start-1 (include-type)
- "Subroutine of `ada-wisi-goto-declaration-start'."
- (let ((start (point))
- (cache (wisi-get-cache (point)))
- (done nil))
- (unless cache
- (setq cache (wisi-backward-cache)))
- ;; cache is null at bob
- (while (not done)
- (if cache
- (progn
- (setq done
- (cl-case (wisi-cache-nonterm cache)
- ((entry_body entry_declaration)
- (eq (wisi-cache-token cache) 'ENTRY))
-
- (full_type_declaration
- (when include-type
- (eq (wisi-cache-token cache) 'TYPE)))
-
- ((generic_package_declaration
generic_subprogram_declaration)
- (eq (wisi-cache-token cache) 'GENERIC))
-
- ((package_body package_declaration)
- (eq (wisi-cache-token cache) 'PACKAGE))
-
- ((protected_body protected_type_declaration
single_protected_declaration)
- (eq (wisi-cache-token cache) 'PROTECTED))
-
- ((abstract_subprogram_declaration
- expression_function_declaration
- subprogram_body
- subprogram_declaration
- subprogram_renaming_declaration
- null_procedure_declaration)
- (memq (wisi-cache-token cache) '(NOT OVERRIDING FUNCTION
PROCEDURE)))
-
- ((single_task_declaration task_body task_type_declaration)
- (eq (wisi-cache-token cache) 'TASK))
-
- ))
- (unless (< start (wisi-cache-end cache))
- ;; found declaration does not include start; find containing one.
- (setq done nil))
- (unless done
- (setq cache (wisi-goto-containing cache nil))))
- (setq done t))
- )
- cache))
-
-(defun ada-wisi-goto-declaration-end ()
- "For `ada-goto-declaration-end', which see."
- ;; first goto-declaration-start, so we get the right end, not just
- ;; the current statement end.
- (wisi-goto-end-1 (ada-wisi-goto-declaration-start)))
-
-(defun ada-wisi-goto-declarative-region-start ()
- "For `ada-goto-declarative-region-start', which see."
- (wisi-validate-cache (point-min) (point-max) t 'navigate)
-
- (let ((done nil)
- start-pos
- (in-package-spec nil)
- (cache (or (wisi-get-cache (point))
- (wisi-backward-cache))))
-
- ;; We use backward-cache, not forward-cache, to handle the case
- ;; where point is in the whitespace or comment before a block; we
- ;; want the containing block, not the next block.
-
- (when cache ;; nil at bob
- ;; If this is called with point in a comment after 'is', then the
- ;; declarative region starts after the comment; don't hang in a
- ;; package spec.
- (setq start-pos (point))
- (while (not done)
- (if (and (or (not in-package-spec)
- (< (point) start-pos))
- (ada-wisi-declarative-region-start-p cache))
- (progn
- (forward-word);; past 'is'
- (setq done t))
- (cl-case (wisi-cache-class cache)
- (motion
- (setq cache (wisi-goto-containing cache)));; statement-start
-
- (statement-end
- (setq cache (wisi-goto-containing cache)) ;; statement-start
- (cl-case (wisi-cache-nonterm cache)
- ((generic_package_declaration
- package_declaration
- entry_body package_body package_declaration protected_body
subprogram_body task_body
- protected_type_declaration single_protected_declaration
single_task_declaration task_type_declaration)
- ;; This is a block scope before the starting point; we want the
containing scope
- (setq cache (wisi-goto-containing cache)))
-
- (t
- nil)
- ))
-
- (statement-start
- (cl-case (wisi-cache-nonterm cache)
- (generic_package_declaration
- (setq in-package-spec t)
- (setq cache (wisi-next-statement-cache cache)) ;; 'package'
- (setq cache (wisi-next-statement-cache cache))) ;; 'is'
-
- (package_declaration
- (setq in-package-spec t)
- (setq cache (wisi-next-statement-cache cache))) ;; 'is'
-
- ((entry_body package_body package_declaration protected_body
subprogram_body task_body)
- (while (not (eq 'IS (wisi-cache-token cache)))
- (setq cache (wisi-next-statement-cache cache))))
-
- ((protected_type_declaration single_protected_declaration
single_task_declaration task_type_declaration)
- (while (not (eq 'IS (wisi-cache-token cache)))
- (setq cache (wisi-next-statement-cache cache)))
- (when (looking-at "\<new\>")
- (while (not (eq 'WITH (wisi-cache-token cache)))
- (setq cache (wisi-next-statement-cache cache)))))
-
- (t
- (setq cache (wisi-goto-containing cache t)))
- ))
-
- (t
- (setq cache (wisi-goto-containing cache t)))
- )))
-
- ;; point is at start of first code statement after
- ;; declaration-start keyword and comment; move back to end of
- ;; keyword.
- (while (forward-comment -1))
- )))
-
-(defun ada-wisi-in-paramlist-p (&optional parse-result)
- "For `ada-in-paramlist-p'."
- (wisi-validate-cache (point-min) (point-max) nil 'navigate)
- ;; (info "(elisp)Parser State" "*syntax-ppss*")
- (let ((parse-result (or parse-result (syntax-ppss)))
- cache)
- (and (> (nth 0 parse-result) 0)
- ;; cache is nil if the parse failed
- (setq cache (wisi-get-cache (nth 1 parse-result)))
- (eq 'formal_part (wisi-cache-nonterm cache)))
- ))
-
-(defun ada-wisi-refactor (action)
- (wisi-validate-cache (line-end-position -7) (line-end-position 7) t
'navigate)
- (save-excursion
- (skip-syntax-backward "w_.\"")
- (let* ((edit-begin (point))
- (cache (wisi-goto-statement-start))
- (parse-begin (point))
- (parse-end (wisi-cache-end cache)))
- (if parse-end
- (setq parse-end (+ parse-end (wisi-cache-last (wisi-get-cache
(wisi-cache-end cache)))))
- ;; else there is a syntax error; missing end of statement
- (setq parse-end (point-max)))
- (wisi-refactor wisi--parser action parse-begin parse-end edit-begin)
- )))
-
-(defun ada-wisi-refactor-1 ()
- "Refactor Method (Object) => Object.Method.
-Point must be in Method."
- (interactive)
- (ada-wisi-refactor ada-refactor-method-object-to-object-method))
-
-(defun ada-wisi-refactor-2 ()
- "Refactor Object.Method => Method (Object).
-Point must be in Object.Method."
- (interactive)
- (ada-wisi-refactor ada-refactor-object-method-to-method-object))
-
-(defun ada-wisi-refactor-3 ()
- "Refactor Element (Object, Index) => Object (Index).
-Point must be in Element"
- (interactive)
- (ada-wisi-refactor ada-refactor-element-object-to-object-index))
-
-(defun ada-wisi-refactor-4 ()
- "Refactor Object (Index) => Element (Object, Index).
-Point must be in Object"
- (interactive)
- (ada-wisi-refactor ada-refactor-object-index-to-element-object))
-
-(defun ada-wisi-make-subprogram-body ()
- "For `ada-make-subprogram-body'."
- ;; point is at start of subprogram specification;
- ;; ada-wisi-expand-region will find the terminal semicolon.
- (wisi-validate-cache (point-min) (point-max) t 'navigate)
-
- (let* ((begin (point))
- (end (wisi-cache-end (wisi-get-cache (point))))
- (name (wisi-next-name)))
- (goto-char end)
- (newline)
- (insert " is begin\n\nend ");; legal syntax; parse does not fail
- (insert name)
- (forward-char 1)
-
- ;; newline after body to separate from next body
- (newline-and-indent)
- (indent-region begin (point))
- (forward-line -2)
- (back-to-indentation)
- ))
-
-(defun ada-wisi-which-function-1 (keyword add-body)
- "Used in `ada-wisi-which-function'."
- (let* ((result (wisi-next-name)))
-
- ;; See comment in ada-mode.el ada-which-function on why we don't
- ;; overwrite ff-function-name.
- (when (not ff-function-name)
- (setq ff-function-name
- (concat
- keyword
- (when add-body "\\s-+body")
- "\\s-+"
- result
- ada-symbol-end)))
- result))
-
-(defun ada-wisi-which-function (include-type)
- "For `ada-which-function'."
- ;; Fail gracefully and silently, since this could be called from
- ;; which-function-mode.
- (let ((parse-begin (max (point-min) (- (point) (/ ada-which-func-parse-size
2))))
- (parse-end (min (point-max) (+ (point) (/ ada-which-func-parse-size
2)))))
- (save-excursion
- (condition-case nil
- ;; Throwing an error here disables which-function-mode, so don't do
it.
- (progn
- (wisi-validate-cache parse-begin parse-end nil 'navigate)
- (when (wisi-cache-covers-region parse-begin parse-end 'navigate)
- (let ((result nil)
- (cache (ada-wisi-goto-declaration-start-1 include-type)))
- (if (null cache)
- ;; bob or failed parse
- (setq result "")
-
- (when (memq (wisi-cache-nonterm cache)
- '(generic_package_declaration
generic_subprogram_declaration))
- ;; name is after next statement keyword
- (setq cache (wisi-next-statement-cache cache)))
-
- ;; add or delete 'body' as needed
- (cl-ecase (wisi-cache-nonterm cache)
- ((entry_body entry_declaration)
- (setq result (ada-wisi-which-function-1 "entry" nil)))
-
- (full_type_declaration
- (setq result (ada-wisi-which-function-1 "type" nil)))
-
- (package_body
- (setq result (ada-wisi-which-function-1 "package" nil)))
-
- ((package_declaration
- package_specification) ;; after 'generic'
- (setq result (ada-wisi-which-function-1 "package" t)))
-
- (protected_body
- (setq result (ada-wisi-which-function-1 "protected" nil)))
-
- ((protected_type_declaration single_protected_declaration)
- (setq result (ada-wisi-which-function-1 "protected" t)))
-
- ((abstract_subprogram_declaration
- expression_function_declaration
- subprogram_declaration
- subprogram_renaming_declaration
- generic_subprogram_declaration ;; after 'generic'
- null_procedure_declaration)
- (setq result (ada-wisi-which-function-1
- (progn (search-forward-regexp
"function\\|procedure")(match-string 0))
- nil))) ;; no 'body' keyword in subprogram
bodies
-
- (subprogram_body
- (setq result (ada-wisi-which-function-1
- (progn (search-forward-regexp
"function\\|procedure")(match-string 0))
- nil)))
-
- ((single_task_declaration task_type_declaration)
- (setq result (ada-wisi-which-function-1 "task" t)))
-
-
- (task_body
- (setq result (ada-wisi-which-function-1 "task" nil)))
- ))
- result)))
- (error "")))
- ))
-
-(cl-defstruct (ada-wisi-parser (:include wisi-process--parser))
- ;; no new slots
- )
-
-(cl-defmethod wisi-parse-format-language-options ((_parser ada-wisi-parser))
- (format "%d %d %d %d %d %d %d %d %d %d %d %d %d"
- ada-indent
- ada-indent-broken
- (if ada-indent-comment-col-0 1 0)
- (if ada-indent-comment-gnat 1 0)
- ada-indent-label
- ada-indent-record-rel-type
- ada-indent-renames
- ada-indent-return
- ada-indent-use
- ada-indent-when
- ada-indent-with
- (if ada-indent-hanging-rel-exp 1 0)
- (if ada-end-name-optional 1 0)
- ))
-
-(defconst ada-wisi-named-begin-regexp
- "\\bfunction\\b\\|\\bpackage\\b\\|\\bprocedure\\b\\|\\btask\\b"
- )
-
-(defconst ada-wisi-partial-begin-regexp
- (concat "\\bbegin\\b\\|\\bdeclare\\b\\|"
- ada-wisi-named-begin-regexp
- "\\|\\bend;\\|\\bend " ada-name-regexp ";"))
-
-(defconst ada-wisi-partial-end-regexp
- (concat ada-wisi-partial-begin-regexp
- "\\|;"))
-
-(defun ada-wisi-find-begin ()
- "Starting at current point, search backward for a parse start point."
-
- ;; There is a trade-off in deciding where to start parsing for indent. If we
have:
- ;;
- ;; procedure ...
- ;; is
- ;;
- ;; and are inserting a new line after 'is', we need to include
- ;; 'is' in the parse to see the indent. On the other hand, if we
- ;; have:
- ;;
- ;; ...
- ;; end;
- ;; begin
- ;; Foo;
- ;;
- ;; Inserting new line after 'Foo;'; if we include 'begin', there
- ;; is no error (begin starts a statement), and the indent is
- ;; computed incorrectly.
- ;;
- ;; This is handled by the set of keywords in
- ;; ada-wisi-partial-begin-regexp.
- (cond
- ((wisi-search-backward-skip
- ada-wisi-partial-begin-regexp
- (lambda () (or (ada-in-string-or-comment-p)
- (looking-back "access " (line-beginning-position)))))
- ;; "access" rejects subprobram access parameters;
test/ada_mode-recover_partial_20.adb
-
- (let ((found (match-string 0))
- cache)
- (cond
- ((and (>= (length found) 3)
- (string-equal "end" (substring found 0 3)))
- (match-end 0))
-
- (t
- (setq cache (wisi-get-cache (point)))
- (when cache
- ;; This distinguishes 'begin' as a statement start from
- ;; 'begin' following 'declare', 'procedure' etc. We don't
- ;; force a parse to get this; the user may choose to do so.
- (wisi-goto-start cache))
- (point))
- )))
-
- (t
- (point-min))
- ))
-
-(defun ada-wisi-find-end ()
- "Starting at current point, search forward for a reasonable parse end point."
- (forward-comment (point-max)) ;; get past any current comments
- (forward-line 1) ;; contain at least some code (see
ada_mode-partial_parse.adb 'blank line before "end"')
-
- (let ((start (point))
- match
- (end-cand nil))
-
- (while (not end-cand)
- (if (search-forward-regexp ada-wisi-partial-end-regexp nil 1) ;; moves
to eob if not found
- (unless (or (ada-in-string-or-comment-p)
- (ada-in-paren-p))
- (setq match t)
- (setq end-cand (point)))
-
- ;; No reasonable end point found (maybe a missing right
- ;; paren); return line after start for minimal parse, compute
- ;; indent for line containing start.
- (setq match nil)
- (goto-char start)
- (setq end-cand (line-end-position 2)))
- )
-
- (when (and match
- (not (string-equal ";" (match-string 0))))
- (setq end-cand (match-beginning 0)))
-
- end-cand))
-
-(defun ada-wisi-find-matching-end ()
- "Starting at current point, search forward for a matching end.
-Point must have been set by `ada-wisi-find-begin'."
- (let (end-regexp)
- ;; Point is at bol
- (back-to-indentation)
- (when (looking-at ada-wisi-named-begin-regexp)
- (skip-syntax-forward "ws")
- (skip-syntax-forward " ")
- (when (looking-at "body\\|type")
- (goto-char (match-end 0))
- (skip-syntax-forward " "))
- (setq end-regexp
- (concat "end +"
- (buffer-substring-no-properties
- (point)
- (progn
- (skip-syntax-forward "ws._")
- (point)))
- ";"))
- (if (search-forward-regexp end-regexp nil t)
- (progn
- (while (and (ada-in-string-or-comment-p)
- (search-forward-regexp end-regexp nil t)))
- (point))
-
- ;; matching end not found
- nil)
- )))
-
-(cl-defmethod wisi-parse-expand-region ((_parser ada-wisi-parser) begin end)
- (let (begin-cand end-cand result)
- (save-excursion
- (goto-char begin)
-
- (setq begin-cand (ada-wisi-find-begin))
- (if (= begin-cand (point-min)) ;; No code between BEGIN and bob
- (progn
- (goto-char end)
- (setq result (cons begin-cand (ada-wisi-find-end))))
-
- (setq end-cand (ada-wisi-find-matching-end))
- (if (and end-cand
- (>= end-cand end))
- (setq result (cons begin-cand end-cand))
- (goto-char end)
- (setq result (cons begin-cand (ada-wisi-find-end))))
-
- ))
- result))
-
-(cl-defmethod wisi-parse-adjust-indent ((_parser ada-wisi-parser) indent
repair)
- (cond
- ((or (wisi-list-memq (wisi--parse-error-repair-inserted repair) '(BEGIN IF
LOOP))
- (wisi-list-memq (wisi--parse-error-repair-deleted repair) '(END)))
- ;; Error token terminates the block containing the start token
- (- indent ada-indent))
-
- ((equal '(CASE IS) (wisi--parse-error-repair-inserted repair))
- (- indent (+ ada-indent ada-indent-when)))
-
- ((equal '(END CASE SEMICOLON) (wisi--parse-error-repair-inserted repair))
- (+ indent (+ ada-indent ada-indent-when)))
-
- (t indent)
- ))
-
-(defvar ada-parser nil) ;; declared, set in ada-mode.el for parser detection
-
-(defun ada-wisi-setup ()
- "Set up a buffer for parsing Ada files with wisi."
- (add-hook 'ada-fix-error-hook #'ada-wisi-fix-error)
-
- (wisi-setup
- :indent-calculate '(ada-wisi-comment)
- :post-indent-fail 'ada-wisi-post-parse-fail
- :parser
- (wisi-process-parse-get
- (make-ada-wisi-parser
- :label "Ada"
- :language-protocol-version ada-wisi-language-protocol-version
- :exec-file ada-process-parse-exec
- :exec-opts ada-process-parse-exec-opts
- :face-table ada-process-face-table
- :token-table ada-process-token-table
- :repair-image ada-process-repair-image)))
-
- (set (make-local-variable 'comment-indent-function) 'wisi-comment-indent)
-
- (add-hook 'hack-local-variables-hook 'ada-wisi-post-local-vars nil t)
- )
-
-(defun ada-wisi-post-local-vars ()
- "See wisi-setup."
- (setq hack-local-variables-hook (delq 'ada-wisi-post-local-vars
hack-local-variables-hook))
-
- (setq wisi-indent-comment-col-0 ada-indent-comment-col-0)
- )
-
-(add-hook 'ada-mode-hook 'ada-wisi-setup)
-
-(setq ada-fix-context-clause 'ada-wisi-context-clause)
-(setq ada-goto-declaration-end 'ada-wisi-goto-declaration-end)
-(setq ada-goto-declaration-start 'ada-wisi-goto-declaration-start)
-(setq ada-goto-declarative-region-start
'ada-wisi-goto-declarative-region-start)
-(setq ada-goto-end 'wisi-goto-statement-end)
-(setq ada-goto-subunit-name 'ada-wisi-goto-subunit-name)
-(setq ada-in-case-expression 'ada-wisi-in-case-expression)
-(setq ada-in-paramlist-p 'ada-wisi-in-paramlist-p)
-(setq ada-indent-statement 'wisi-indent-statement)
-(setq ada-make-subprogram-body 'ada-wisi-make-subprogram-body)
-(setq ada-on-context-clause 'ada-wisi-on-context-clause)
-(setq ada-reset-parser 'wisi-reset-parser)
-(setq ada-show-parse-error 'wisi-show-parse-error)
-(setq ada-which-function 'ada-wisi-which-function)
-
-(provide 'ada-wisi)
-;; end of file
diff --git a/packages/ada-mode/ada-xref.el b/packages/ada-mode/ada-xref.el
deleted file mode 100644
index 6816d8a..0000000
--- a/packages/ada-mode/ada-xref.el
+++ /dev/null
@@ -1,5 +0,0 @@
-;;; ada-xref.el --- Dummy file to hide obsolete bundled version -*-
lexical-binding:t -*-
-;;; see xref-ada.el for Emacs 25 xref minor mode for ada-mode
-(require 'ada-mode)
-(provide 'ada-xref)
-(message "'ada-xref' is obsolete; use 'ada-mode' instead")
diff --git a/packages/ada-mode/ada.wy b/packages/ada-mode/ada.wy
index dcdd709..415d727 100644
--- a/packages/ada-mode/ada.wy
+++ b/packages/ada-mode/ada.wy
@@ -121,6 +121,7 @@
%token <right-paren> RIGHT_PAREN ")"
%token <punctuation> AMPERSAND "&"
+%token <punctuation> AT_SIGN "@"
%token <punctuation> BAR "|"
%token <punctuation> BOX "<>"
%token <punctuation> COLON ":"
@@ -258,7 +259,7 @@
;; Error recovery will insert 'end if;', after push_back or
;; undo_reduce of the handled_sequence_of_statements including
;; 'statement'. If it uses push_back, then 'end if;' is before
-;; 'statement'; if undo_reduce, after, which is the desired result.;;
+;; 'statement'; if undo_reduce, after, which is the desired result.
%mckenzie_cost_undo_reduce handled_sequence_of_statements 0
%mckenzie_cost_undo_reduce sequence_of_statements 0
%mckenzie_cost_undo_reduce sequence_of_statements_opt 0
@@ -283,21 +284,19 @@
;; known conflicts that are resolved by generalized LALR parser
%conflict REDUCE/REDUCE in state abstract_limited_opt,
abstract_limited_synchronized_opt on token NEW
%conflict REDUCE/REDUCE in state actual_parameter_part, actual_parameter_part
on token RIGHT_PAREN
-%conflict REDUCE/REDUCE in state aggregate, aggregate on token RIGHT_PAREN (
580)
+%conflict REDUCE/REDUCE in state aggregate, aggregate on token RIGHT_PAREN
%conflict REDUCE/REDUCE in state association_opt, expression_opt on token
RIGHT_PAREN
%conflict REDUCE/REDUCE in state derived_type_definition,
derived_type_definition on token WITH
%conflict REDUCE/REDUCE in state full_type_declaration, full_type_declaration
on token NEW
%conflict REDUCE/REDUCE in state identifier_list, name on token COMMA
%conflict REDUCE/REDUCE in state name, direct_name on token USE
%conflict REDUCE/REDUCE in state primary, subtype_indication on token COMMA
-%if parser = LALR
-%conflict REDUCE/REDUCE in state primary, subtype_indication on token
EQUAL_GREATER
-%end if
%conflict REDUCE/REDUCE in state primary, subtype_indication on token
RIGHT_PAREN
%conflict REDUCE/REDUCE in state range_list, discrete_subtype_definition on
token COMMA
%conflict REDUCE/REDUCE in state range_list, discrete_subtype_definition on
token RIGHT_PAREN
%conflict SHIFT/REDUCE in state abstract_subprogram_declaration,
abstract_subprogram_declaration on token IS
%conflict SHIFT/REDUCE in state accept_statement, accept_statement on token
LEFT_PAREN
+%conflict SHIFT/REDUCE in state aggregate, expression_opt on token WITH
%conflict SHIFT/REDUCE in state aspect_clause, name on token USE
%conflict SHIFT/REDUCE in state association_opt, name on token EQUAL_GREATER
%conflict SHIFT/REDUCE in state attribute_designator, attribute_designator on
token LEFT_PAREN
@@ -325,6 +324,10 @@
%conflict SHIFT/REDUCE in state task_body, task_body on token IS
%conflict SHIFT/REDUCE in state wisitoken_accept, wisitoken_accept on token
FOR
+%if parser = LALR
+%conflict REDUCE/REDUCE in state primary, subtype_indication on token
EQUAL_GREATER
+%end if
+
;;;; grammar rules
;;
;; The actions cache information in keywords that are significant for
@@ -377,25 +380,22 @@ abstract_tagged_limited_opt
abstract_subprogram_declaration
: overriding_indicator_opt subprogram_specification IS ABSTRACT
aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 2 statement-override 6
statement-end])
- (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken nil
nil])))%
+ %((wisi-statement-action [1 statement-start 2 statement-override 6
statement-end])
+ (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken nil
nil]))%
;
accept_statement
: ACCEPT IDENTIFIER actual_parameter_part_opt parameter_profile_opt DO
handled_sequence_of_statements END identifier_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 5 motion 9 statement-end])
+ %((wisi-statement-action [1 statement-start 5 motion 9 statement-end])
(wisi-motion-action [1 5 [6 WHEN] 9])
(wisi-face-apply-action [2 nil font-lock-function-name-face 8 nil
font-lock-function-name-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken [nil ada-indent] [ada-indent ada-indent] nil nil nil])))%
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken [nil ada-indent] [ada-indent ada-indent] nil nil nil]))%
%((wisi-match-names 2 8))%
| ACCEPT IDENTIFIER actual_parameter_part_opt parameter_profile_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 5 statement-end])
+ %((wisi-statement-action [1 statement-start 5 statement-end])
(wisi-face-apply-action [2 nil font-lock-function-name-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken nil])))%
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken nil]))%
;
;; same as access_type_definition for our purposes
@@ -442,6 +442,10 @@ aggregate
%((wisi-indent-action [nil (wisi-anchored 1 1) (wisi-anchored 1 1)
[(wisi-anchored 1 1) (wisi-anchored 1 1)]
(wisi-anchored 1 0)]))%
| LEFT_PAREN NULL RECORD RIGHT_PAREN
+ | LEFT_PAREN expression WITH DELTA association_list RIGHT_PAREN ;;
record_delta_aggregate, array_delta_aggregate
+ %((wisi-indent-action [nil (wisi-anchored 1 1) (wisi-anchored 1 1)
(wisi-anchored 1 1)
+ [(wisi-anchored 1 1) (wisi-anchored 1 1)]
+ (wisi-anchored 1 0)]))%
;; ARM 4.5.7(7), ARM 4.5.8(4) allow ( conditional|quantified_expression )
instead of (( ... ))
| LEFT_PAREN conditional_quantified_expression RIGHT_PAREN
@@ -472,7 +476,8 @@ array_type_definition
aspect_clause
: FOR attribute_reference USE expression_opt SEMICOLON ;;
attribute_definition_clause
- %((wisi-statement-action [1 statement-start 5 statement-end]))%
+ %((wisi-statement-action [1 statement-start 5 statement-end])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken nil]))%
| enumeration_representation_clause
| record_representation_clause
| at_clause
@@ -491,14 +496,13 @@ aspect_specification_opt
assignment_statement
: name COLON_EQUAL expression_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 4 statement-end])
+ %((wisi-statement-action [1 statement-start 4 statement-end])
(wisi-indent-action [nil
ada-indent-broken
(wisi-hanging
(wisi-anchored% 2 ada-indent-broken)
(wisi-anchored% 3 ada-indent-broken))
- nil])))%
+ nil]))%
;
association_opt
@@ -530,6 +534,9 @@ association_opt
(wisi-anchored% 2 (* 2
ada-indent-broken)))]]))%
| discrete_choice_list EQUAL_GREATER BOX
%((wisi-indent-action [(wisi-hanging nil ada-indent-broken)
ada-indent-broken nil]))%
+ | FOR IDENTIFIER IN discrete_choice_list EQUAL_GREATER expression ;;
iterated_component_association
+ %((wisi-indent-action [nil nil nil (wisi-hanging nil ada-indent-broken)
ada-indent-broken
+ [(wisi-hanging nil ada-indent-broken)
(wisi-hanging nil ada-indent-broken)]]))%
| expression
;; test/ada_mode-parens.adb Hello
%((wisi-indent-action [[(wisi-hanging nil ada-indent-broken) (wisi-hanging
nil ada-indent-broken)]]))%
@@ -543,11 +550,10 @@ association_list
asynchronous_select
: SELECT triggering_alternative THEN ABORT sequence_of_statements_opt END
SELECT SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 3 motion 8 statement-end])
+ %((wisi-statement-action [1 statement-start 3 motion 8 statement-end])
(wisi-motion-action [1 3 8])
(wisi-indent-action [nil [ada-indent ada-indent] [nil
ada-indent-broken] ada-indent-broken
- [ada-indent ada-indent] nil nil nil])))%
+ [ada-indent ada-indent] nil nil nil]))%
;
at_clause
@@ -586,16 +592,14 @@ block_label_opt
block_statement
: block_label_opt DECLARE declarative_part_opt BEGIN
handled_sequence_of_statements END identifier_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 2 motion 4 motion 8
statement-end])
+ %((wisi-statement-action [1 statement-start 2 motion 4 motion 8
statement-end])
(wisi-motion-action [2 4 [5 WHEN] 8])
- (wisi-indent-action [nil nil [ada-indent ada-indent] nil [ada-indent
ada-indent] nil nil nil])))%
+ (wisi-indent-action [nil nil [ada-indent ada-indent] nil [ada-indent
ada-indent] nil nil nil]))%
%((wisi-match-names 1 7))%
| block_label_opt BEGIN handled_sequence_of_statements END identifier_opt
SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 2 motion 6 statement-end])
+ %((wisi-statement-action [1 statement-start 2 motion 6 statement-end])
(wisi-motion-action [2 [3 WHEN] 6])
- (wisi-indent-action [nil nil [ada-indent ada-indent] nil nil nil])))%
+ (wisi-indent-action [nil nil [ada-indent ada-indent] nil nil nil]))%
%((wisi-match-names 1 5))%
;
@@ -606,10 +610,9 @@ body_stub
case_expression
: CASE expression_opt IS case_expression_alternative_list
- %((progn
- (wisi-statement-action [1 motion])
+ %((wisi-statement-action [1 motion])
(wisi-motion-action [1 4])
- (wisi-indent-action [nil ada-indent-broken nil ada-indent-when])))%
+ (wisi-indent-action [nil ada-indent-broken nil ada-indent-when]))%
;
case_expression_alternative
@@ -618,35 +621,30 @@ case_expression_alternative
;; when A =>
;; J = 4
;; or else M, -- test case from Piotr Trojanek
- %((progn
- (wisi-statement-action [1 motion])
+ %((wisi-statement-action [1 motion])
(wisi-indent-action [nil ada-indent-broken ada-indent-broken
(wisi-hanging (wisi-anchored% 1 ada-indent)
- (wisi-anchored% 1 (+ ada-indent
ada-indent-broken)))])))%
+ (wisi-anchored% 1 (+ ada-indent
ada-indent-broken)))]))%
;
case_expression_alternative_list
: case_expression_alternative_list COMMA case_expression_alternative
- %((progn
- (wisi-motion-action [1 3])
- (wisi-indent-action [nil [nil ada-indent-when] nil])))%
+ %((wisi-motion-action [1 3]))%
| case_expression_alternative
;
case_statement
: CASE expression_opt IS case_statement_alternative_list END CASE SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 7 statement-end])
+ %((wisi-statement-action [1 statement-start 7 statement-end])
(wisi-motion-action [1 4 7])
- (wisi-indent-action [nil ada-indent-broken nil [ada-indent-when
ada-indent-when] nil nil nil])))%
+ (wisi-indent-action [nil ada-indent-broken nil [ada-indent-when
ada-indent-when] nil nil nil]))%
;
case_statement_alternative
: WHEN discrete_choice_list EQUAL_GREATER sequence_of_statements_opt
- %((progn
- (wisi-statement-action [1 motion])
+ %((wisi-statement-action [1 motion])
;; ada-indent-when added in case_statement
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken [ada-indent
ada-indent]])))%
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken [ada-indent
ada-indent]]))%
;
;; We don't allow an empty list here; that leads to parallel parser
@@ -690,9 +688,8 @@ compilation_unit_list
component_clause
: IDENTIFIER AT simple_expression RANGE simple_expression DOT_DOT
simple_expression SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 8 statement-end])
- (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken ada-indent-broken nil])))%
+ %((wisi-statement-action [1 statement-start 8 statement-end])
+ (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken ada-indent-broken nil]))%
;
component_clause_list
@@ -702,15 +699,13 @@ component_clause_list
component_declaration
: identifier_list COLON component_definition COLON_EQUAL expression_opt
aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 7 statement-end])
+ %((wisi-statement-action [1 statement-start 7 statement-end])
(wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken
(wisi-anchored% 4 ada-indent-broken)
- ada-indent-broken nil])))%
+ ada-indent-broken nil]))%
| identifier_list COLON component_definition aspect_specification_opt
SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 5 statement-end])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken nil])))%
+ %((wisi-statement-action [1 statement-start 5 statement-end])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken nil]))%
;
component_definition
@@ -751,10 +746,9 @@ compound_statement
conditional_entry_call
: SELECT entry_call_alternative ELSE sequence_of_statements_opt END SELECT
SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 3 motion 7 statement-end])
+ %((wisi-statement-action [1 statement-start 3 motion 7 statement-end])
(wisi-motion-action [1 3 7])
- (wisi-indent-action [nil [ada-indent ada-indent] nil [ada-indent
ada-indent] nil nil nil])))%
+ (wisi-indent-action [nil [ada-indent ada-indent] nil [ada-indent
ada-indent] nil nil nil]))%
;
conditional_quantified_expression
@@ -794,10 +788,9 @@ declaration
| generic_instantiation
| null_procedure_declaration
| identifier_list COLON CONSTANT COLON_EQUAL expression_opt SEMICOLON ;;
number_declaration
- %((progn
- (wisi-statement-action [1 statement-start 6 statement-end])
+ %((wisi-statement-action [1 statement-start 6 statement-end])
(wisi-indent-action [(wisi-hanging nil ada-indent-broken)
ada-indent-broken ada-indent-broken ada-indent-broken
- (wisi-anchored% 4 ada-indent-broken) nil])))%
+ (wisi-anchored% 4 ada-indent-broken) nil]))%
| object_declaration
| package_declaration
| renaming_declaration
@@ -830,18 +823,18 @@ delay_alternative
delay_statement
: DELAY UNTIL expression_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 4 statement-end])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil])))%
+ %((wisi-statement-action [1 statement-start 4 statement-end])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil]))%
| DELAY expression_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 3 statement-end])
- (wisi-indent-action [nil ada-indent-broken nil])))%
+ %((wisi-statement-action [1 statement-start 3 statement-end])
+ (wisi-indent-action [nil ada-indent-broken nil]))%
;
derived_type_definition
: abstract_limited_opt NEW name and_interface_list_opt WITH record_definition
- %((wisi-face-apply-action [3 font-lock-function-name-face
font-lock-type-face]))%
+ %((wisi-face-apply-action [3 font-lock-function-name-face
font-lock-type-face])
+ ;; comment after 'with' same as 'record'
+ (wisi-indent-action [nil nil nil nil [nil (ada-indent-record* 'TYPE 6
0)] nil]))%
| abstract_limited_opt NEW name constraint_opt
%((wisi-face-apply-action [3 font-lock-function-name-face
font-lock-type-face]))%
;
@@ -902,10 +895,9 @@ discriminant_specification_list
elsif_expression_item
: ELSIF expression_opt THEN expression_opt
- %((progn
- (wisi-statement-action [1 motion 3 motion])
+ %((wisi-statement-action [1 motion 3 motion])
(wisi-motion-action [1 3])
- (wisi-indent-action [nil [ada-indent-broken ada-indent-broken] nil
ada-indent])))%
+ (wisi-indent-action [nil [ada-indent-broken ada-indent-broken] nil
ada-indent]))%
;
elsif_expression_list
@@ -916,10 +908,9 @@ elsif_expression_list
elsif_statement_item
: ELSIF expression_opt THEN sequence_of_statements_opt
- %((progn
- (wisi-statement-action [1 motion 3 motion])
+ %((wisi-statement-action [1 motion 3 motion])
(wisi-motion-action [1 3])
- (wisi-indent-action [nil [ada-indent-broken ada-indent-broken] nil
[ada-indent ada-indent]])))%
+ (wisi-indent-action [nil [ada-indent-broken ada-indent-broken] nil
[ada-indent ada-indent]]))%
;
elsif_statement_list
@@ -931,8 +922,7 @@ elsif_statement_list
entry_body
: ENTRY IDENTIFIER entry_body_formal_part WHEN expression_opt
IS declarative_part_opt BEGIN handled_sequence_of_statements END
identifier_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 4 motion 6 motion 8 motion
12 statement-end])
+ %((wisi-statement-action [1 statement-start 4 motion 6 motion 8 motion 12
statement-end])
(wisi-name-action 2)
(wisi-motion-action [1 4 6 8 [9 WHEN] 12])
(wisi-face-apply-action [2 nil font-lock-function-name-face 11 nil
font-lock-function-name-face])
@@ -948,7 +938,7 @@ entry_body
;; (Local_2 = 1)
(wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken
(wisi-anchored% 4 ada-indent-broken)
- nil [ada-indent ada-indent] nil [ada-indent
ada-indent] nil nil nil])))%
+ nil [ada-indent ada-indent] nil [ada-indent
ada-indent] nil nil nil]))%
%((wisi-match-names 2 11))%
;
@@ -967,18 +957,16 @@ entry_call_alternative
entry_declaration
: overriding_indicator_opt ENTRY IDENTIFIER LEFT_PAREN
discrete_subtype_definition RIGHT_PAREN
parameter_profile_opt aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 2 statement-override 8
statement-end])
+ %((wisi-statement-action [1 statement-start 2 statement-override 8
statement-end])
(wisi-name-action 3)
(wisi-face-apply-action [3 nil font-lock-function-name-face])
(wisi-indent-action [nil nil ada-indent-broken ada-indent-broken
(wisi-anchored 4 1) (wisi-anchored 4 0)
- ada-indent-broken nil nil])))%
+ ada-indent-broken nil nil]))%
| overriding_indicator_opt ENTRY IDENTIFIER parameter_profile_opt
aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 2 statement-override 6
statement-end])
+ %((wisi-statement-action [1 statement-start 2 statement-override 6
statement-end])
(wisi-name-action 3)
(wisi-face-apply-action [3 nil font-lock-function-name-face])
- (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken
ada-indent-broken nil])))%
+ (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken
ada-indent-broken nil]))%
;
enumeration_literal ;; enumeration_literal_specification
@@ -993,10 +981,9 @@ enumeration_literal_list
enumeration_representation_clause
: FOR name USE aggregate SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 5 statement-end])
+ %((wisi-statement-action [1 statement-start 5 statement-end])
(wisi-face-apply-action [2 font-lock-function-name-face
font-lock-type-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken nil])))%
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken nil]))%
;
enumeration_type_definition
@@ -1020,14 +1007,12 @@ exception_declaration
exception_handler
: WHEN IDENTIFIER COLON exception_choice_list EQUAL_GREATER
sequence_of_statements_opt
- %((progn
- (wisi-statement-action [1 motion])
+ %((wisi-statement-action [1 motion])
(wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken
- [ada-indent ada-indent]])))%
+ [ada-indent ada-indent]]))%
| WHEN exception_choice_list EQUAL_GREATER sequence_of_statements_opt
- %((progn
- (wisi-statement-action [1 motion])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken [ada-indent
ada-indent]])))%
+ %((wisi-statement-action [1 motion])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken [ada-indent
ada-indent]]))%
;
exception_handler_list
@@ -1044,9 +1029,8 @@ exception_handler_list_opt
exit_statement
: EXIT identifier_opt WHEN expression_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 5 statement-end])
- (wisi-indent-action [nil nil nil ada-indent-broken nil])))%
+ %((wisi-statement-action [1 statement-start 5 statement-end])
+ (wisi-indent-action [nil nil nil ada-indent-broken nil]))%
| EXIT identifier_opt SEMICOLON
%((wisi-statement-action [1 statement-start 3 statement-end]))%
;
@@ -1069,9 +1053,8 @@ expression_function_declaration
: overriding_indicator_opt function_specification IS paren_expression
aspect_specification_opt SEMICOLON
;; IS does not start a block, so it is not "motion".
;;
- %((progn
- (wisi-statement-action [1 statement-start 2 statement-override 6
statement-end])
- (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken
ada-indent-broken nil])))%
+ %((wisi-statement-action [1 statement-start 2 statement-override 6
statement-end])
+ (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken
ada-indent-broken nil]))%
;
extended_return_object_declaration
@@ -1089,13 +1072,11 @@ extended_return_object_declaration_opt
extended_return_statement
: RETURN extended_return_object_declaration_opt DO
handled_sequence_of_statements END RETURN SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 3 motion 7 statement-end])
+ %((wisi-statement-action [1 statement-start 3 motion 7 statement-end])
(wisi-motion-action [1 3 [4 WHEN] 7])
- (wisi-indent-action [[nil ada-indent] ada-indent-broken nil [ada-indent
ada-indent] nil nil nil])))%
+ (wisi-indent-action [[nil ada-indent] ada-indent-broken nil [ada-indent
ada-indent] nil nil nil]))%
| RETURN extended_return_object_declaration SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 3 statement-end])))%
+ %((wisi-statement-action [1 statement-start 3 statement-end]))%
;; indent the same as a simple return statment
;; test/ada_mode-nominal.adb
;; return B : Integer :=
@@ -1115,78 +1096,66 @@ factor
formal_object_declaration
: identifier_list COLON mode_opt null_exclusion_opt name COLON_EQUAL
expression_opt aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 9 statement-end])
+ %((wisi-statement-action [1 statement-start 9 statement-end])
(wisi-face-apply-action [5 font-lock-function-name-face
font-lock-type-face])
(wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken ada-indent-broken
- (wisi-anchored% 6 ada-indent-broken)
ada-indent-broken nil])))%
+ (wisi-anchored% 6 ada-indent-broken)
ada-indent-broken nil]))%
| identifier_list COLON mode_opt access_definition COLON_EQUAL
expression_opt aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 8 statement-end])
+ %((wisi-statement-action [1 statement-start 8 statement-end])
(wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken
- (wisi-anchored% 5 ada-indent-broken)
ada-indent-broken nil])))%
+ (wisi-anchored% 5 ada-indent-broken)
ada-indent-broken nil]))%
| identifier_list COLON mode_opt null_exclusion_opt name
aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 7 statement-end])
+ %((wisi-statement-action [1 statement-start 7 statement-end])
(wisi-face-apply-action [5 font-lock-function-name-face
font-lock-type-face])
(wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken
- ada-indent-broken nil])))%
+ ada-indent-broken nil]))%
| identifier_list COLON mode_opt access_definition aspect_specification_opt
SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 6 statement-end])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken nil])))%
+ %((wisi-statement-action [1 statement-start 6 statement-end])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken nil]))%
;
formal_part
: LEFT_PAREN parameter_specification_list RIGHT_PAREN
- %((progn
- (wisi-statement-action [1 misc]) ;; for ada-wisi-in-paramlist-p
- (wisi-indent-action [nil (wisi-anchored 1 1) (wisi-anchored 1 0)])))%
+ %((wisi-statement-action [1 misc]) ;; for ada-wisi-in-paramlist-p,
ada-goto-declarative-region-start
+ (wisi-indent-action [nil (wisi-anchored 1 1) (wisi-anchored 1 0)]))%
;
formal_subprogram_declaration
: WITH subprogram_specification IS ABSTRACT subprogram_default
aspect_specification_opt SEMICOLON
;; formal_abstract_subprogram_declaration
- %((progn
- (wisi-statement-action [1 statement-start 7 statement-end])
- (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken nil])))%
+ %((wisi-statement-action [1 statement-start 7 statement-end])
+ (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken nil]))%
| WITH subprogram_specification IS subprogram_default
aspect_specification_opt SEMICOLON
;; formal_concrete_subprogram_declaration
- %((progn
- (wisi-statement-action [1 statement-start 6 statement-end])
- (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken
ada-indent-broken nil])))%
+ %((wisi-statement-action [1 statement-start 6 statement-end])
+ (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken
ada-indent-broken nil]))%
| WITH subprogram_specification IS ABSTRACT aspect_specification_opt
SEMICOLON
;; formal_abstract_subprogram_declaration
- %((progn
- (wisi-statement-action [1 statement-start 6 statement-end])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken nil])))%
+ %((wisi-statement-action [1 statement-start 6 statement-end])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken nil]))%
| WITH subprogram_specification aspect_specification_opt SEMICOLON ;;
formal_concrete_subprogram_declaration
- %((progn
- (wisi-statement-action [1 statement-start 4 statement-end])
- (wisi-indent-action [nil nil ada-indent-broken nil])))%
+ %((wisi-statement-action [1 statement-start 4 statement-end])
+ (wisi-indent-action [nil nil ada-indent-broken nil]))%
;
formal_type_declaration
: TYPE IDENTIFIER discriminant_part_opt IS formal_type_definition
aspect_specification_opt SEMICOLON
;; formal_complete_type_declaration
- %((progn
- (wisi-statement-action [1 statement-start 7 statement-end])
+ %((wisi-statement-action [1 statement-start 7 statement-end])
(wisi-face-apply-action [2 nil font-lock-type-face])
(wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken
- ada-indent-broken ada-indent-broken nil])))%
+ ada-indent-broken ada-indent-broken nil]))%
| TYPE IDENTIFIER discriminant_part_opt IS TAGGED aspect_specification_opt
SEMICOLON
;; formal_incomplete_type_declaration
- %((progn
- (wisi-statement-action [1 statement-start 7 statement-end])
+ %((wisi-statement-action [1 statement-start 7 statement-end])
(wisi-face-apply-action [2 nil font-lock-type-face])
(wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken
- ada-indent-broken nil])))%
+ ada-indent-broken nil]))%
| TYPE IDENTIFIER discriminant_part_opt aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 5 statement-end])
+ %((wisi-statement-action [1 statement-start 5 statement-end])
(wisi-face-apply-action [2 nil font-lock-type-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken nil])))%
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken nil]))%
;
formal_type_definition
@@ -1214,11 +1183,10 @@ formal_derived_type_definition
formal_package_declaration
: WITH PACKAGE name IS NEW name formal_package_actual_part
aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 9 statement-end])
+ %((wisi-statement-action [1 statement-start 9 statement-end])
(wisi-face-apply-action [3 font-lock-function-name-face
font-lock-function-name-face
6 font-lock-function-name-face
font-lock-function-name-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken ada-indent-broken ada-indent-broken
ada-indent-broken nil])))%
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken ada-indent-broken ada-indent-broken
ada-indent-broken nil]))%
;
formal_package_actual_part
@@ -1234,27 +1202,25 @@ formal_package_actual_part
full_type_declaration
: TYPE IDENTIFIER discriminant_part_opt IS type_definition
aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 7 statement-end])
+ %((wisi-statement-action [1 statement-start 7 statement-end])
(wisi-name-action 2)
(wisi-face-apply-action [2 nil font-lock-type-face])
- ;; FIXME: indentation of comment after 'is' (and 'with' in
- ;; derived_type_definition) should be ada-indent-record-rel-type
- ;; if type_definition is a record. Worse if
- ;; ada-indent-comment-gnat is t. Need 'anchor to next line'.
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken nil nil])))%
+ ;; Indentation of comment after 'is' is
+ ;; ada-indent-record-rel-type if type_definition is a record.
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
+ [ada-indent-broken (ada-indent-record* 'TYPE
5 ada-indent-broken)]
+ ada-indent-broken nil nil]))%
| task_type_declaration
| protected_type_declaration
;
function_specification
: FUNCTION name parameter_and_result_profile
- %((progn
- (wisi-statement-action [1 statement-start])
+ %((wisi-statement-action [1 statement-start])
(wisi-name-action 2)
(wisi-face-apply-action [2 font-lock-function-name-face
font-lock-function-name-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken])))%
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken]))%
%((wisi-propagate-name 2))%
;
@@ -1275,9 +1241,8 @@ generic_declaration
generic_formal_part
: GENERIC generic_formal_parameter_declarations
- %((progn
- (wisi-statement-action [1 statement-start])
- (wisi-indent-action [nil ada-indent])))%
+ %((wisi-statement-action [1 statement-start])
+ (wisi-indent-action [nil ada-indent]))%
| GENERIC
%((wisi-statement-action [1 statement-start]))%
;
@@ -1299,91 +1264,80 @@ generic_formal_parameter_declaration
generic_instantiation
;; name generic_actual_part is included in name as a function call
: PACKAGE name IS NEW name aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 7 statement-end])
+ %((wisi-statement-action [1 statement-start 7 statement-end])
(wisi-name-action 2)
(wisi-face-apply-action [2 font-lock-function-name-face
font-lock-function-name-face
5 font-lock-function-name-face
font-lock-function-name-face])
- (wisi-indent-action [nil ada-indent-broken nil ada-indent-broken
ada-indent-broken ada-indent-broken nil])))%
+ (wisi-indent-action [nil ada-indent-broken nil ada-indent-broken
ada-indent-broken ada-indent-broken nil]))%
| overriding_indicator_opt PROCEDURE name IS NEW name
aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 2 statement-override 8
statement-end])
+ %((wisi-statement-action [1 statement-start 2 statement-override 8
statement-end])
(wisi-name-action 3)
(wisi-face-apply-action [3 font-lock-function-name-face
font-lock-function-name-face
6 font-lock-function-name-face
font-lock-function-name-face])
- (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken ada-indent-broken nil])))%
+ (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken ada-indent-broken nil]))%
| overriding_indicator_opt FUNCTION name IS NEW name
aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 2 statement-override 8
statement-end])
+ %((wisi-statement-action [1 statement-start 2 statement-override 8
statement-end])
(wisi-name-action 3)
(wisi-face-apply-action [3 font-lock-function-name-face
font-lock-function-name-face
6 font-lock-function-name-face
font-lock-function-name-face])
(wisi-indent-action [nil nil ada-indent-broken nil ada-indent-broken
ada-indent-broken ada-indent-broken
- nil])))%
+ nil]))%
;
generic_package_declaration
: generic_formal_part package_specification SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 3 statement-end])
+ %((wisi-statement-action [1 statement-start 3 statement-end])
(wisi-motion-action [1 2 3])
- (wisi-indent-action [[nil ada-indent] nil nil])))%
+ (wisi-indent-action [[nil ada-indent] nil nil]))%
;
generic_renaming_declaration
: GENERIC PACKAGE name RENAMES name aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 7 statement-end])
+ %((wisi-statement-action [1 statement-start 7 statement-end])
(wisi-name-action 3)
(wisi-face-apply-action [3 font-lock-function-name-face
font-lock-function-name-face
5 font-lock-function-name-face
font-lock-function-name-face])
- (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken nil])))%
+ (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken nil]))%
| GENERIC PROCEDURE name RENAMES name aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 7 statement-end])
+ %((wisi-statement-action [1 statement-start 7 statement-end])
(wisi-name-action 3)
(wisi-face-apply-action [3 font-lock-function-name-face
font-lock-function-name-face
5 font-lock-function-name-face
font-lock-function-name-face])
(wisi-indent-action [nil nil ada-indent-broken (ada-indent-renames 3)
ada-indent-broken ada-indent-broken
- nil])))%
+ nil]))%
| GENERIC FUNCTION name RENAMES name aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 7 statement-end])
+ %((wisi-statement-action [1 statement-start 7 statement-end])
(wisi-name-action 3)
(wisi-face-apply-action [3 font-lock-function-name-face
font-lock-function-name-face
5 font-lock-function-name-face
font-lock-function-name-face])
(wisi-indent-action [nil nil ada-indent-broken (ada-indent-renames 3)
ada-indent-broken ada-indent-broken
- nil])))%
+ nil]))%
;
generic_subprogram_declaration
: generic_formal_part subprogram_specification aspect_specification_opt
SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 2 statement-override 4
statement-end])
- (wisi-motion-action [1 2 4])))%
+ %((wisi-statement-action [1 statement-start 2 statement-override 4
statement-end])
+ (wisi-motion-action [1 2 4]))%
;
goto_label
: LESS_LESS IDENTIFIER GREATER_GREATER
- %((progn
- (wisi-face-apply-action [2 nil font-lock-constant-face])
- (wisi-indent-action [ada-indent-label nil nil])))%
+ %((wisi-face-apply-action [2 nil font-lock-constant-face])
+ (wisi-indent-action [ada-indent-label nil nil]))%
;
handled_sequence_of_statements
: sequence_of_statements_opt EXCEPTION exception_handler_list_opt
- %((progn
- (wisi-indent-action [[nil nil]
+ %((wisi-indent-action [[nil nil]
(- ada-indent)
- [(- ada-indent-when ada-indent) (-
ada-indent-when ada-indent)]])))%
+ [(- ada-indent-when ada-indent) (-
ada-indent-when ada-indent)]]))%
| sequence_of_statements_opt
;
identifier_list
: identifier_list COMMA IDENTIFIER
- %((progn
- (wisi-name-action 3)
- (wisi-indent-action [nil nil ada-indent-broken])))%
+ %((wisi-name-action 3)
+ (wisi-indent-action [nil nil ada-indent-broken]))%
| IDENTIFIER
%((wisi-name-action 1))%
;
@@ -1397,79 +1351,69 @@ identifier_opt
if_expression
: IF expression_opt THEN expression_opt elsif_expression_list ELSE
expression_opt
- %((progn
- (wisi-statement-action [1 motion 3 motion 6 motion])
+ %((wisi-statement-action [1 motion 3 motion 6 motion])
(wisi-motion-action [1 3 5 6])
- (wisi-indent-action [nil [ada-indent-broken ada-indent-broken] nil
ada-indent nil nil ada-indent])))%
+ (wisi-indent-action [nil [ada-indent-broken ada-indent-broken] nil
ada-indent nil nil ada-indent]))%
| IF expression_opt THEN expression_opt ELSE expression_opt
- %((progn
- (wisi-statement-action [1 motion 3 motion 5 motion])
+ %((wisi-statement-action [1 motion 3 motion 5 motion])
(wisi-motion-action [1 3 5])
- (wisi-indent-action [nil [ada-indent-broken ada-indent-broken] nil
ada-indent nil ada-indent])))%
+ (wisi-indent-action [nil [ada-indent-broken ada-indent-broken] nil
ada-indent nil ada-indent]))%
| IF expression_opt THEN expression_opt elsif_expression_list
- %((progn
- (wisi-statement-action [1 motion 3 motion])
+ %((wisi-statement-action [1 motion 3 motion])
(wisi-motion-action [1 3 5])
- (wisi-indent-action [nil [ada-indent-broken ada-indent-broken] nil
ada-indent nil])))%
+ (wisi-indent-action [nil [ada-indent-broken ada-indent-broken] nil
ada-indent nil]))%
| IF expression_opt THEN expression_opt
- %((progn
- (wisi-statement-action [1 motion 3 motion])
+ %((wisi-statement-action [1 motion 3 motion])
(wisi-motion-action [1 3])
- (wisi-indent-action [nil [ada-indent-broken ada-indent-broken] nil
ada-indent])))%
+ (wisi-indent-action [nil [ada-indent-broken ada-indent-broken] nil
ada-indent]))%
;
if_statement
: IF expression_opt THEN sequence_of_statements_opt elsif_statement_list ELSE
sequence_of_statements_opt END IF SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 3 motion 6 motion 10
statement-end])
+ %((wisi-statement-action [1 statement-start 3 motion 6 motion 10
statement-end])
(wisi-motion-action [1 3 5 6 10])
(wisi-indent-action [nil
[(wisi-hanging% ada-indent-broken (* 2
ada-indent-broken))
ada-indent-broken]
nil
[ada-indent ada-indent] nil nil
- [ada-indent ada-indent] nil nil nil])))%
+ [ada-indent ada-indent] nil nil nil]))%
| IF expression_opt THEN sequence_of_statements_opt ELSE
sequence_of_statements_opt END IF SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 3 motion 5 motion 9
statement-end])
+ %((wisi-statement-action [1 statement-start 3 motion 5 motion 9
statement-end])
(wisi-motion-action [1 3 5 9])
(wisi-indent-action [nil [(wisi-hanging% ada-indent-broken (* 2
ada-indent-broken))
ada-indent-broken]
nil
[ada-indent ada-indent] nil
- [ada-indent ada-indent] nil nil nil])))%
+ [ada-indent ada-indent] nil nil nil]))%
| IF expression_opt THEN sequence_of_statements_opt elsif_statement_list END
IF SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 3 motion 8 statement-end])
+ %((wisi-statement-action [1 statement-start 3 motion 8 statement-end])
(wisi-motion-action [1 3 5 8])
(wisi-indent-action [nil [(wisi-hanging% ada-indent-broken (* 2
ada-indent-broken))
ada-indent-broken]
nil
- [ada-indent ada-indent] nil nil nil nil])))%
+ [ada-indent ada-indent] nil nil nil nil]))%
| IF expression_opt THEN sequence_of_statements_opt END IF SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 3 motion 7 statement-end])
+ %((wisi-statement-action [1 statement-start 3 motion 7 statement-end])
(wisi-motion-action [1 3 7])
(wisi-indent-action [nil [(wisi-hanging% ada-indent-broken (* 2
ada-indent-broken))
ada-indent-broken]
nil
- [ada-indent ada-indent] nil nil nil])))%
+ [ada-indent ada-indent] nil nil nil]))%
;
incomplete_type_declaration
: TYPE IDENTIFIER discriminant_part_opt IS TAGGED SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 6 statement-end])
+ %((wisi-statement-action [1 statement-start 6 statement-end])
(wisi-name-action 2)
(wisi-face-apply-action [2 nil font-lock-type-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken nil])))%
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken nil]))%
| TYPE IDENTIFIER discriminant_part_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 3 statement-end])
+ %((wisi-statement-action [1 statement-start 3 statement-end])
(wisi-name-action 2)
(wisi-face-apply-action [2 nil font-lock-type-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil])))%
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil]))%
;
index_constraint
@@ -1548,16 +1492,14 @@ iterator_specification_opt
loop_statement
: block_label_opt iteration_scheme LOOP sequence_of_statements_opt END LOOP
identifier_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 2 statement-override 3 motion
8 statement-end])
+ %((wisi-statement-action [1 statement-start 2 statement-override 3 motion
8 statement-end])
(wisi-motion-action [2 3 8])
- (wisi-indent-action [nil nil nil [ada-indent ada-indent] nil nil nil
nil])))%
+ (wisi-indent-action [nil nil nil [ada-indent ada-indent] nil nil nil
nil]))%
%((wisi-match-names 1 7))%
| block_label_opt LOOP sequence_of_statements_opt END LOOP identifier_opt
SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 2 statement-override 4 motion
7 statement-end])
+ %((wisi-statement-action [1 statement-start 2 statement-override 4 motion
7 statement-end])
(wisi-motion-action [2 4 7])
- (wisi-indent-action [nil nil [ada-indent ada-indent] nil nil nil nil])))%
+ (wisi-indent-action [nil nil [ada-indent ada-indent] nil nil nil nil]))%
%((wisi-match-names 1 6))%
;
@@ -1637,10 +1579,9 @@ name
;; := F_Long_Name
;; (A => True,
;; B => True);
- %((progn
- (wisi-indent-action [nil (if ada-indent-hanging-rel-exp
+ %((wisi-indent-action [nil (if ada-indent-hanging-rel-exp
(wisi-anchored 1 ada-indent-broken)
- (wisi-anchored% 1 ada-indent-broken))])))%
+ (wisi-anchored% 1 ada-indent-broken))]))%
| selected_component ;; starts with name
%()%
@@ -1663,6 +1604,8 @@ name
%()%
%((wisi-propagate-name 1))%
+ | AT_SIGN ;; target_name
+
;; | explicit_dereference in selected_component
;; | indexed_component same as 'name actual_parameter_part' above
;; | generalized_reference same as 'name'
@@ -1695,70 +1638,60 @@ null_exclusion_opt_name_type
null_procedure_declaration
: overriding_indicator_opt procedure_specification IS NULL
aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 2 statement-override 6
statement-end])
- (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken
ada-indent-broken nil])))%
+ %((wisi-statement-action [1 statement-start 2 statement-override 6
statement-end])
+ (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken
ada-indent-broken nil]))%
;
object_declaration
: identifier_list COLON aliased_opt constant_opt subtype_indication
COLON_EQUAL
expression_opt aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 9 statement-end])
+ %((wisi-statement-action [1 statement-start 9 statement-end])
(wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken ada-indent-broken
- (wisi-anchored%- 6 ada-indent-broken)
ada-indent-broken nil])))%
+ (wisi-anchored%- 6 ada-indent-broken)
ada-indent-broken nil]))%
| identifier_list COLON aliased_opt constant_opt access_definition
COLON_EQUAL
expression_opt aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 9 statement-end])
+ %((wisi-statement-action [1 statement-start 9 statement-end])
(wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken ada-indent-broken
- (wisi-anchored% 6 ada-indent-broken)
ada-indent-broken nil])))%
+ (wisi-anchored% 6 ada-indent-broken)
ada-indent-broken nil]))%
| identifier_list COLON aliased_opt constant_opt array_type_definition
COLON_EQUAL
expression_opt aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 9 statement-end])
+ %((wisi-statement-action [1 statement-start 9 statement-end])
(wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken ada-indent-broken
- (wisi-anchored% 6 ada-indent-broken)
ada-indent-broken nil])))%
+ (wisi-anchored% 6 ada-indent-broken)
ada-indent-broken nil]))%
| identifier_list COLON aliased_opt constant_opt subtype_indication
aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 7 statement-end])
+ %((wisi-statement-action [1 statement-start 7 statement-end])
(wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken
- ada-indent-broken nil])))%
+ ada-indent-broken nil]))%
| identifier_list COLON aliased_opt constant_opt access_definition
aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 7 statement-end])
+ %((wisi-statement-action [1 statement-start 7 statement-end])
(wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken
- ada-indent-broken nil])))%
+ ada-indent-broken nil]))%
| identifier_list COLON aliased_opt constant_opt array_type_definition
aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 7 statement-end])
+ %((wisi-statement-action [1 statement-start 7 statement-end])
(wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken
- ada-indent-broken nil])))%
+ ada-indent-broken nil]))%
| single_task_declaration
| single_protected_declaration
;
object_renaming_declaration
: IDENTIFIER COLON null_exclusion_opt name RENAMES name
aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 8 statement-end])
- (wisi-name-action 1)
- (wisi-face-apply-action [4 font-lock-function-name-face
font-lock-type-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken
- ada-indent-broken ada-indent-broken nil])))%
+ %((wisi-statement-action [1 statement-start 8 statement-end])
+ (wisi-name-action 1)
+ (wisi-face-apply-action [4 font-lock-function-name-face
font-lock-type-face])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken
+ ada-indent-broken ada-indent-broken nil]))%
| IDENTIFIER COLON access_definition RENAMES name aspect_specification_opt
SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 7 statement-end])
- (wisi-name-action 1)
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken
- ada-indent-broken nil])))%
+ %((wisi-statement-action [1 statement-start 7 statement-end])
+ (wisi-name-action 1)
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken
+ ada-indent-broken nil]))%
| IDENTIFIER COLON EXCEPTION RENAMES name aspect_specification_opt SEMICOLON
;; exception_renaming_declaration
- %((progn
- (wisi-statement-action [1 statement-start 7 statement-end])
- (wisi-name-action 1)
- (wisi-face-apply-action [5 font-lock-function-name-face nil])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken
- ada-indent-broken nil])))%
+ %((wisi-statement-action [1 statement-start 7 statement-end])
+ (wisi-name-action 1)
+ (wisi-face-apply-action [5 font-lock-function-name-face nil])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken
+ ada-indent-broken nil]))%
;
;; operator_symbol is STRING_LITERAL, in name
@@ -1774,73 +1707,66 @@ overriding_indicator_opt
package_body
: PACKAGE BODY name aspect_specification_opt IS declarative_part_opt
BEGIN handled_sequence_of_statements END name_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 5 motion 7 motion 11
statement-end])
- (wisi-name-action 3)
- (wisi-motion-action [1 5 7 [8 WHEN] 11])
- (wisi-face-apply-action [3 font-lock-function-name-face
font-lock-function-name-face
- 10 font-lock-function-name-face
font-lock-function-name-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil nil
[ada-indent ada-indent]
- nil [ada-indent ada-indent] nil ada-indent-broken
nil])))%
+ %((wisi-statement-action [1 statement-start 5 motion 7 motion 11
statement-end])
+ (wisi-name-action 3)
+ (wisi-motion-action [1 5 7 [8 WHEN] 11])
+ (wisi-face-apply-action [3 font-lock-function-name-face
font-lock-function-name-face
+ 10 font-lock-function-name-face
font-lock-function-name-face])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil nil
[ada-indent ada-indent]
+ nil [ada-indent ada-indent] nil
ada-indent-broken nil]))%
%((wisi-match-names 3 10))%
| PACKAGE BODY name aspect_specification_opt IS declarative_part_opt END
name_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 5 motion 9 statement-end])
- (wisi-name-action 3)
- (wisi-motion-action [1 5 9])
- (wisi-face-apply-action [3 font-lock-function-name-face
font-lock-function-name-face
- 8 font-lock-function-name-face
font-lock-function-name-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken nil [ada-indent ada-indent] nil
- nil nil])))%
+ %((wisi-statement-action [1 statement-start 5 motion 9 statement-end])
+ (wisi-name-action 3)
+ (wisi-motion-action [1 5 9])
+ (wisi-face-apply-action [3 font-lock-function-name-face
font-lock-function-name-face
+ 8 font-lock-function-name-face
font-lock-function-name-face])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken nil [ada-indent ada-indent] nil
+ nil nil]))%
%((wisi-match-names 3 8))%
;
package_body_stub
: PACKAGE BODY name IS SEPARATE aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 7 statement-end])
- (wisi-name-action 3)
- (wisi-face-apply-action [3 font-lock-function-name-face
font-lock-function-name-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil
ada-indent-broken ada-indent-broken nil])))%
+ %((wisi-statement-action [1 statement-start 7 statement-end])
+ (wisi-name-action 3)
+ (wisi-face-apply-action [3 font-lock-function-name-face
font-lock-function-name-face])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil
ada-indent-broken ada-indent-broken nil]))%
;
package_declaration
: package_specification SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 2 statement-end])
- (wisi-motion-action [1 2])))%
+ %((wisi-statement-action [1 statement-start 2 statement-end])
+ (wisi-motion-action [1 2]))%
;
package_renaming_declaration
: PACKAGE name RENAMES name aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 6 statement-end])
- (wisi-name-action 2)
- (wisi-face-apply-action [2 font-lock-function-name-face
font-lock-function-name-face
- 4 font-lock-function-name-face
font-lock-function-name-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken nil])))%
+ %((wisi-statement-action [1 statement-start 6 statement-end])
+ (wisi-name-action 2)
+ (wisi-face-apply-action [2 font-lock-function-name-face
font-lock-function-name-face
+ 4 font-lock-function-name-face
font-lock-function-name-face])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken nil]))%
;
package_specification
: PACKAGE name aspect_specification_opt IS declarative_part_opt PRIVATE
declarative_part_opt END name_opt
- %((progn
- (wisi-statement-action [1 statement-start 4 motion 6 motion])
- (wisi-name-action 2)
- (wisi-motion-action [1 4 6])
- (wisi-face-apply-action [2 font-lock-function-name-face
font-lock-function-name-face
- 9 font-lock-function-name-face
font-lock-function-name-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil
[ada-indent ada-indent] nil
- [ada-indent ada-indent] nil nil])))%
+ %((wisi-statement-action [1 statement-start 4 motion 6 motion])
+ (wisi-name-action 2)
+ (wisi-motion-action [1 4 6])
+ (wisi-face-apply-action [2 font-lock-function-name-face
font-lock-function-name-face
+ 9 font-lock-function-name-face
font-lock-function-name-face])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil
[ada-indent ada-indent] nil
+ [ada-indent ada-indent] nil nil]))%
%((wisi-match-names 2 9))%
| PACKAGE name aspect_specification_opt IS declarative_part_opt END name_opt
- %((progn
- (wisi-statement-action [1 statement-start 4 motion])
+ %((wisi-statement-action [1 statement-start 4 motion])
(wisi-name-action 2)
(wisi-motion-action [1 4])
(wisi-face-apply-action [2 font-lock-function-name-face
font-lock-function-name-face
7 font-lock-function-name-face
font-lock-function-name-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil
[ada-indent ada-indent] nil nil])))%
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil
[ada-indent ada-indent] nil nil]))%
%((wisi-match-names 2 7))%
;
@@ -1860,15 +1786,13 @@ parameter_profile_opt
parameter_specification
: identifier_list COLON aliased_opt mode_opt null_exclusion_opt name
COLON_EQUAL expression_opt
- %((progn
- (wisi-face-apply-action [6 font-lock-function-name-face
font-lock-type-face])
+ %((wisi-face-apply-action [6 font-lock-function-name-face
font-lock-type-face])
(wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken
- ada-indent-broken ada-indent-broken
(wisi-anchored% 7 ada-indent-broken)])))%
+ ada-indent-broken ada-indent-broken
(wisi-anchored% 7 ada-indent-broken)]))%
| identifier_list COLON aliased_opt mode_opt null_exclusion_opt name
- %((progn
- (wisi-face-apply-action [6 font-lock-function-name-face
font-lock-type-face])
+ %((wisi-face-apply-action [6 font-lock-function-name-face
font-lock-type-face])
(wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken
- ada-indent-broken])))%
+ ada-indent-broken]))%
| identifier_list COLON aliased_opt access_definition COLON_EQUAL
expression_opt
%((wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken
(wisi-anchored% 5 ada-indent-broken)]))%
@@ -1900,21 +1824,18 @@ paren_expression
pragma_g
: PRAGMA IDENTIFIER LEFT_PAREN association_list RIGHT_PAREN SEMICOLON
;; ARM has 'pragma_argument_association'; this is a superset, and reduces
redundancy
- %((progn
- (wisi-statement-action [1 statement-start 6 statement-end])
+ %((wisi-statement-action [1 statement-start 6 statement-end])
(wisi-face-apply-action [2 nil font-lock-function-name-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
(wisi-anchored 3 1) (wisi-anchored 3 0) nil])))%
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
(wisi-anchored 3 1) (wisi-anchored 3 0) nil]))%
;; ARM 4.5.7(7), ARM 4.5.8(4) allow ( conditional|quantified_expression )
instead of (( ... ))
| PRAGMA IDENTIFIER LEFT_PAREN conditional_quantified_expression RIGHT_PAREN
SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 6 statement-end])
+ %((wisi-statement-action [1 statement-start 6 statement-end])
(wisi-face-apply-action [2 nil font-lock-function-name-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
(wisi-anchored 3 1) (wisi-anchored 3 0) nil])))%
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
(wisi-anchored 3 1) (wisi-anchored 3 0) nil]))%
| PRAGMA IDENTIFIER SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 3 statement-end])
+ %((wisi-statement-action [1 statement-start 3 statement-end])
(wisi-face-apply-action [2 nil font-lock-function-name-face])
- (wisi-indent-action [nil ada-indent-broken nil])))%
+ (wisi-indent-action [nil ada-indent-broken nil]))%
;
;; prefix is name
@@ -1937,38 +1858,34 @@ primary
private_extension_declaration
: TYPE IDENTIFIER discriminant_part_opt IS abstract_limited_synchronized_opt
NEW
subtype_indication and_interface_list_opt WITH PRIVATE
aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 12 statement-end])
- (wisi-name-action 2)
- (wisi-face-apply-action [2 nil font-lock-type-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken ada-indent-broken
- ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken nil nil])))%
+ %((wisi-statement-action [1 statement-start 12 statement-end])
+ (wisi-name-action 2)
+ (wisi-face-apply-action [2 nil font-lock-type-face])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken ada-indent-broken
+ ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken nil nil]))%
;
private_type_declaration
: TYPE IDENTIFIER discriminant_part_opt IS abstract_tagged_limited_opt
PRIVATE aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 8 statement-end])
- (wisi-name-action 2)
- (wisi-face-apply-action [2 nil font-lock-type-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil
ada-indent-broken ada-indent-broken nil
- nil])))%
+ %((wisi-statement-action [1 statement-start 8 statement-end])
+ (wisi-name-action 2)
+ (wisi-face-apply-action [2 nil font-lock-type-face])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil
ada-indent-broken ada-indent-broken nil
+ nil]))%
;
procedure_call_statement
: name SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 2 statement-end])
- (wisi-indent-action [(wisi-hanging nil ada-indent-broken) nil])))%
+ %((wisi-statement-action [1 statement-start 2 statement-end])
+ (wisi-indent-action [(wisi-hanging nil ada-indent-broken) nil]))%
;
procedure_specification
: PROCEDURE name parameter_profile_opt
- %((progn
- (wisi-statement-action [1 statement-start])
- (wisi-name-action 2)
- (wisi-face-apply-action [2 font-lock-function-name-face
font-lock-function-name-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken])))%
+ %((wisi-statement-action [1 statement-start])
+ (wisi-name-action 2)
+ (wisi-face-apply-action [2 font-lock-function-name-face
font-lock-function-name-face])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken]))%
%((wisi-propagate-name 2))%
;
@@ -1981,36 +1898,32 @@ proper_body
protected_body
: PROTECTED BODY IDENTIFIER aspect_specification_opt IS
protected_operation_item_list_opt END identifier_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 5 motion 9 statement-end])
- (wisi-name-action 3)
- (wisi-motion-action [1 5 9])
- (wisi-face-apply-action [3 nil font-lock-type-face 8 nil
font-lock-type-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil nil
ada-indent nil nil nil])))%
+ %((wisi-statement-action [1 statement-start 5 motion 9 statement-end])
+ (wisi-name-action 3)
+ (wisi-motion-action [1 5 9])
+ (wisi-face-apply-action [3 nil font-lock-type-face 8 nil
font-lock-type-face])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil nil
ada-indent nil nil nil]))%
%((wisi-match-names 3 8))%
;
protected_body_stub
: PROTECTED BODY IDENTIFIER IS SEPARATE aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 7 statement-end])
- (wisi-name-action 3)
- (wisi-face-apply-action [3 nil font-lock-type-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken ada-indent-broken nil])))%
+ %((wisi-statement-action [1 statement-start 7 statement-end])
+ (wisi-name-action 3)
+ (wisi-face-apply-action [3 nil font-lock-type-face])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken ada-indent-broken ada-indent-broken nil]))%
;
protected_definition
: declarative_part_opt PRIVATE declarative_part_opt END identifier_opt
- %((progn
- (wisi-statement-action [2 motion])
+ %((wisi-statement-action [2 motion])
(wisi-face-apply-action [5 nil font-lock-type-face])
- (wisi-indent-action [[ada-indent ada-indent] nil [ada-indent ada-indent]
nil nil])))%
+ (wisi-indent-action [[ada-indent ada-indent] nil [ada-indent ada-indent]
nil nil]))%
%((wisi-propagate-name 5))%
| declarative_part_opt END identifier_opt
- %((progn
- (wisi-face-apply-action [3 nil font-lock-type-face])
- (wisi-indent-action [[ada-indent ada-indent] nil nil])))%
+ %((wisi-face-apply-action [3 nil font-lock-type-face])
+ (wisi-indent-action [[ada-indent ada-indent] nil nil]))%
%((wisi-propagate-name 3))%
;
@@ -2041,21 +1954,19 @@ protected_opt
protected_type_declaration
: PROTECTED TYPE IDENTIFIER discriminant_part_opt aspect_specification_opt IS
NEW interface_list WITH protected_definition SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 6 motion 11 statement-end])
- (wisi-name-action 3)
- (wisi-motion-action [1 6 [10 PRIVATE] 11])
- (wisi-face-apply-action [3 nil font-lock-type-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken nil nil
- ada-indent-broken ada-indent-broken
ada-indent-broken nil nil])))%
+ %((wisi-statement-action [1 statement-start 6 motion 11 statement-end])
+ (wisi-name-action 3)
+ (wisi-motion-action [1 6 [10 PRIVATE] 11])
+ (wisi-face-apply-action [3 nil font-lock-type-face])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken nil nil
+ ada-indent-broken ada-indent-broken
ada-indent-broken nil nil]))%
%((wisi-match-names 3 10))%
| PROTECTED TYPE IDENTIFIER discriminant_part_opt aspect_specification_opt
IS protected_definition SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 6 motion 8 statement-end])
- (wisi-name-action 3)
- (wisi-motion-action [1 6 [7 PRIVATE] 8])
- (wisi-face-apply-action [3 nil font-lock-type-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken nil [nil ada-indent] nil nil])))%
+ %((wisi-statement-action [1 statement-start 6 motion 8 statement-end])
+ (wisi-name-action 3)
+ (wisi-motion-action [1 6 [7 PRIVATE] 8])
+ (wisi-face-apply-action [3 nil font-lock-type-face])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken nil [nil ada-indent] nil nil]))%
%((wisi-match-names 3 7))%
;
@@ -2063,11 +1974,10 @@ protected_type_declaration
qualified_expression
: name tick aggregate
- %((progn
- (wisi-face-apply-action [1 font-lock-function-name-face
font-lock-type-face])
+ %((wisi-face-apply-action [1 font-lock-function-name-face
font-lock-type-face])
(wisi-indent-action [nil nil (if ada-indent-hanging-rel-exp
- (wisi-anchored 1 ada-indent-broken)
- (wisi-anchored% 1 ada-indent-broken))])))%
+ (wisi-anchored 1 ada-indent-broken)
+ (wisi-anchored% 1 ada-indent-broken))]))%
;
quantified_expression
@@ -2085,8 +1995,7 @@ raise_expression
raise_statement
: RAISE name WITH expression_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 5 statement-end])
+ %((wisi-statement-action [1 statement-start 5 statement-end])
;; test/ada_mode-nominal.adb
;; raise Constraint_Error with
;; "help " &
@@ -2095,11 +2004,10 @@ raise_statement
;; raise Constraint_Error
;; with Integer'Image (1) &
;; "help!";
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
(wisi-anchored% 3 ada-indent-broken) nil])))%
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
(wisi-anchored% 3 ada-indent-broken) nil]))%
| RAISE name SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 3 statement-end])
- (wisi-indent-action [nil ada-indent-broken nil])))%
+ %((wisi-statement-action [1 statement-start 3 statement-end])
+ (wisi-indent-action [nil ada-indent-broken nil]))%
| RAISE SEMICOLON
%((wisi-statement-action [1 statement-start 2 statement-end]))%
;
@@ -2124,24 +2032,23 @@ real_range_specification_opt
record_definition
: RECORD component_list_opt END RECORD
%((wisi-indent-action [[(ada-indent-record* 'TYPE 1 0) (ada-indent-record*
'TYPE 1 ada-indent)]
- [(ada-indent-record* 'TYPE 1 ada-indent)
(ada-indent-record* 'TYPE 1 ada-indent)]
- (ada-indent-record* 'TYPE 1 0)
- nil]))%
+ [(ada-indent-record* 'TYPE 1 ada-indent)
(ada-indent-record* 'TYPE 1 ada-indent)]
+ (ada-indent-record* 'TYPE 1 0)
+ nil]))%
;; ' terminate quote
| NULL RECORD
;
record_representation_clause
: FOR name USE RECORD mod_clause_opt component_clause_list END RECORD
SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 5 statement-end])
+ %((wisi-statement-action [1 statement-start 5 statement-end])
(wisi-face-apply-action [2 font-lock-function-name-face
font-lock-type-face])
(wisi-indent-action [nil ada-indent-broken ada-indent-broken
- (ada-indent-record 1 4 0)
- (ada-indent-record 1 4 ada-indent)
- (ada-indent-record 1 4 ada-indent)
- (ada-indent-record 1 4 0)
- nil nil])))%
+ [(ada-indent-record* 'FOR 4 0)
(ada-indent-record* 'FOR 4 ada-indent)]
+ (ada-indent-record 1 4 ada-indent)
+ [(ada-indent-record* 'FOR 4 ada-indent)
(ada-indent-record* 'FOR 4 ada-indent)]
+ (ada-indent-record* 'FOR 4 0)
+ nil nil]))%
;
relation_and_list
@@ -2200,12 +2107,11 @@ requeue_statement
;; not in LRM; used to implement consistent indentation
result_profile
: RETURN null_exclusion_opt name_opt
- %((progn
- (wisi-face-apply-action [3 font-lock-function-name-face
font-lock-type-face])
+ %((wisi-face-apply-action [3 font-lock-function-name-face
font-lock-type-face])
(wisi-indent-action* 1
[nil
(wisi-anchored* 1 ada-indent-broken)
- (wisi-anchored* 1 ada-indent-broken)])))%
+ (wisi-anchored* 1 ada-indent-broken)]))%
| RETURN access_definition
;; test/ada_mode-nominal.adb
;; function Function_Access_1
@@ -2241,32 +2147,27 @@ selected_component
selective_accept
: SELECT select_alternative_list_opt ELSE sequence_of_statements_opt END
SELECT SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 3 motion 7 statement-end])
+ %((wisi-statement-action [1 statement-start 3 motion 7 statement-end])
(wisi-motion-action [1 [2 OR] 3 7])
- (wisi-indent-action [[nil ada-indent] [nil ada-indent] nil [ada-indent
ada-indent] nil nil nil])))%
+ (wisi-indent-action [[nil ada-indent] [nil ada-indent] nil [ada-indent
ada-indent] nil nil nil]))%
| SELECT select_alternative_list_opt END SELECT SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 5 statement-end])
+ %((wisi-statement-action [1 statement-start 5 statement-end])
(wisi-motion-action [1 [2 OR] 5])
- (wisi-indent-action [[nil ada-indent] [nil ada-indent] nil nil nil])))%
+ (wisi-indent-action [[nil ada-indent] [nil ada-indent] nil nil nil]))%
;
select_alternative
;; we can't use guard_opt here because when present a guard is a
;; block-start, but when absent there is no block-start
: WHEN expression_opt EQUAL_GREATER accept_statement
sequence_of_statements_opt ;; guard accept_alternative
- %((progn
- (wisi-statement-action [1 motion])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken ada-indent
ada-indent])))%
+ %((wisi-statement-action [1 motion])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken ada-indent
ada-indent]))%
| WHEN expression_opt EQUAL_GREATER TERMINATE SEMICOLON ;;
terminate_alternative
- %((progn
- (wisi-statement-action [1 motion 4 statement-start 5 statement-end])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken ada-indent
nil])))%
+ %((wisi-statement-action [1 motion 4 statement-start 5 statement-end])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken ada-indent
nil]))%
| WHEN expression_opt EQUAL_GREATER delay_alternative
- %((progn
- (wisi-statement-action [1 motion])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent])))%
+ %((wisi-statement-action [1 motion])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent]))%
| accept_statement sequence_of_statements_opt ;; accept_alternative
| TERMINATE SEMICOLON ;; terminate_alternative
%((wisi-statement-action [1 statement-start 2 statement-end]))%
@@ -2275,10 +2176,9 @@ select_alternative
select_alternative_list
: select_alternative_list OR select_alternative
- %((progn
- (wisi-statement-action [2 motion])
+ %((wisi-statement-action [2 motion])
(wisi-motion-action [[1 OR] 2])
- (wisi-indent-action [nil nil ada-indent])))%
+ (wisi-indent-action [nil nil ada-indent]))%
| select_alternative
%((wisi-indent-action [ada-indent]))%
;
@@ -2319,9 +2219,8 @@ simple_return_statement
;; return
;; 1.0 +
;; 2.0;
- %((progn
- (wisi-statement-action [1 statement-start 3 statement-end])
- (wisi-indent-action [nil ada-indent-broken nil])))%
+ %((wisi-statement-action [1 statement-start 3 statement-end])
+ (wisi-indent-action [nil ada-indent-broken nil]))%
;
simple_statement
@@ -2330,9 +2229,8 @@ simple_statement
| assignment_statement
| exit_statement
| GOTO IDENTIFIER SEMICOLON ;; goto_statement
- %((progn
- (wisi-statement-action [1 statement-start 3 statement-end])
- (wisi-face-apply-action [2 nil font-lock-constant-face])))%
+ %((wisi-statement-action [1 statement-start 3 statement-end])
+ (wisi-face-apply-action [2 nil font-lock-constant-face]))%
| procedure_call_statement
| simple_return_statement
;; | entry_call_statement ; covered by procedure_call_statement
@@ -2347,51 +2245,46 @@ simple_statement
single_protected_declaration
: PROTECTED IDENTIFIER aspect_specification_opt IS NEW interface_list WITH
protected_definition SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 4 motion 7 motion 9
statement-end])
- (wisi-name-action 2)
- (wisi-motion-action [1 4 7 [8 PRIVATE] 9])
- (wisi-face-apply-action [2 nil font-lock-type-face])
- (wisi-indent-action [nil ada-indent-broken nil nil ada-indent-broken
ada-indent-broken ada-indent-broken nil
- nil])))%
+ %((wisi-statement-action [1 statement-start 4 motion 7 motion 9
statement-end])
+ (wisi-name-action 2)
+ (wisi-motion-action [1 4 7 [8 PRIVATE] 9])
+ (wisi-face-apply-action [2 nil font-lock-type-face])
+ (wisi-indent-action [nil ada-indent-broken nil nil ada-indent-broken
ada-indent-broken ada-indent-broken nil
+ nil]))%
%((wisi-match-names 2 8))%
| PROTECTED IDENTIFIER aspect_specification_opt IS protected_definition
SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 4 motion 6 statement-end])
- (wisi-name-action 2)
- (wisi-motion-action [1 4 [5 PRIVATE] 6])
- (wisi-face-apply-action [2 nil font-lock-type-face])
- (wisi-indent-action [nil ada-indent-broken nil [nil ada-indent] nil
nil])))%
+ %((wisi-statement-action [1 statement-start 4 motion 6 statement-end])
+ (wisi-name-action 2)
+ (wisi-motion-action [1 4 [5 PRIVATE] 6])
+ (wisi-face-apply-action [2 nil font-lock-type-face])
+ (wisi-indent-action [nil ada-indent-broken nil [nil ada-indent] nil
nil]))%
%((wisi-match-names 2 5))%
;
single_task_declaration
: TASK IDENTIFIER aspect_specification_opt IS NEW interface_list WITH
task_definition END identifier_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 4 motion 11 statement-end])
- (wisi-name-action 2)
- (wisi-motion-action [1 4 [8 PRIVATE] 11])
- (wisi-face-apply-action [2 nil font-lock-type-face 9 nil
font-lock-type-face])
- (wisi-indent-action [nil ada-indent-broken nil nil ada-indent-broken
ada-indent-broken ada-indent-broken nil
- nil nil nil])))%
+ %((wisi-statement-action [1 statement-start 4 motion 11 statement-end])
+ (wisi-name-action 2)
+ (wisi-motion-action [1 4 [8 PRIVATE] 11])
+ (wisi-face-apply-action [2 nil font-lock-type-face 9 nil
font-lock-type-face])
+ (wisi-indent-action [nil ada-indent-broken nil nil ada-indent-broken
ada-indent-broken ada-indent-broken nil
+ nil nil nil]))%
%((wisi-match-names 2 10))%
| TASK IDENTIFIER aspect_specification_opt IS task_definition END
identifier_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 4 motion 8 statement-end])
- (wisi-name-action 2)
- (wisi-motion-action [1 4 [5 PRIVATE] 8])
- (wisi-face-apply-action [2 nil font-lock-type-face 6 nil
font-lock-type-face])
- (wisi-indent-action [nil ada-indent-broken nil [nil ada-indent] nil
nil nil nil])))%
+ %((wisi-statement-action [1 statement-start 4 motion 8 statement-end])
+ (wisi-name-action 2)
+ (wisi-motion-action [1 4 [5 PRIVATE] 8])
+ (wisi-face-apply-action [2 nil font-lock-type-face 6 nil
font-lock-type-face])
+ (wisi-indent-action [nil ada-indent-broken nil [nil ada-indent] nil nil
nil nil]))%
%((wisi-match-names 2 7))%
| TASK IDENTIFIER aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 4 statement-end])
- (wisi-name-action 2)
- (wisi-face-apply-action [2 nil font-lock-type-face])
- (wisi-indent-action [nil ada-indent-broken nil nil])))%
+ %((wisi-statement-action [1 statement-start 4 statement-end])
+ (wisi-name-action 2)
+ (wisi-face-apply-action [2 nil font-lock-type-face])
+ (wisi-indent-action [nil ada-indent-broken nil nil]))%
;
statement
@@ -2403,20 +2296,18 @@ statement
subprogram_body
: overriding_indicator_opt subprogram_specification aspect_specification_opt
IS declarative_part_opt
BEGIN handled_sequence_of_statements END name_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 2 statement-override 4 motion
6 motion 10 statement-end])
+ %((wisi-statement-action [1 statement-start 2 statement-override 4 motion
6 motion 10 statement-end])
(wisi-motion-action [1 2 4 6 [7 WHEN] 10])
(wisi-face-apply-action [9 font-lock-function-name-face
font-lock-function-name-face])
(wisi-indent-action [nil [nil ada-indent] nil nil [ada-indent ada-indent]
- nil [ada-indent ada-indent] nil ada-indent-broken
nil])))%
+ nil [ada-indent ada-indent] nil ada-indent-broken
nil]))%
%((wisi-match-names 2 9))%
;
subprogram_body_stub
: overriding_indicator_opt subprogram_specification IS SEPARATE
aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 2 statement-override 6
statement-end])
- (wisi-indent-action [nil nil nil ada-indent-broken ada-indent-broken
nil])))%
+ %((wisi-statement-action [1 statement-start 2 statement-override 6
statement-end])
+ (wisi-indent-action [nil nil nil ada-indent-broken ada-indent-broken
nil]))%
;
subprogram_declaration
@@ -2432,10 +2323,9 @@ subprogram_default
subprogram_renaming_declaration
: overriding_indicator_opt subprogram_specification RENAMES name
aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 2 statement-override 6
statement-end])
+ %((wisi-statement-action [1 statement-start 2 statement-override 6
statement-end])
(wisi-face-apply-action [4 font-lock-function-name-face
font-lock-function-name-face])
- (wisi-indent-action [nil nil (ada-indent-renames 2) ada-indent-broken
ada-indent-broken nil])))%
+ (wisi-indent-action [nil nil (ada-indent-renames 2) ada-indent-broken
ada-indent-broken nil]))%
;
subprogram_specification
@@ -2449,11 +2339,10 @@ subprogram_specification
subtype_declaration
: SUBTYPE IDENTIFIER IS subtype_indication aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 6 statement-end])
- (wisi-name-action 2)
- (wisi-face-apply-action [2 nil font-lock-type-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken nil nil])))%
+ %((wisi-statement-action [1 statement-start 6 statement-end])
+ (wisi-name-action 2)
+ (wisi-face-apply-action [2 nil font-lock-type-face])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken nil nil]))%
;
subtype_indication
@@ -2474,31 +2363,28 @@ subtype_indication
subunit
: SEPARATE LEFT_PAREN name RIGHT_PAREN proper_body
- %((progn
- (wisi-statement-action [1 statement-start 5 statement-override])
- (wisi-indent-action [nil ada-indent-broken (wisi-anchored 2 1)
(wisi-anchored 2 0) nil])))%
+ %((wisi-statement-action [1 statement-start 5 statement-override])
+ (wisi-indent-action [nil ada-indent-broken (wisi-anchored 2 1)
(wisi-anchored 2 0) nil]))%
;
task_body
: TASK BODY IDENTIFIER aspect_specification_opt IS declarative_part_opt
BEGIN handled_sequence_of_statements END identifier_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 5 motion 7 motion 11
statement-end])
- (wisi-name-action 3)
- (wisi-motion-action [1 5 7 [8 WHEN] 11])
- (wisi-face-apply-action [3 nil font-lock-type-face 10 nil
font-lock-type-face])
- (wisi-indent-action [nil nil ada-indent-broken nil nil [ada-indent
ada-indent]
- nil [ada-indent ada-indent] nil nil nil])))%
+ %((wisi-statement-action [1 statement-start 5 motion 7 motion 11
statement-end])
+ (wisi-name-action 3)
+ (wisi-motion-action [1 5 7 [8 WHEN] 11])
+ (wisi-face-apply-action [3 nil font-lock-type-face 10 nil
font-lock-type-face])
+ (wisi-indent-action [nil nil ada-indent-broken nil nil [ada-indent
ada-indent]
+ nil [ada-indent ada-indent] nil nil nil]))%
%((wisi-match-names 3 10))%
;
task_body_stub
: TASK BODY IDENTIFIER IS SEPARATE aspect_specification_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 7 statement-end])
- (wisi-name-action 3)
- (wisi-face-apply-action [3 nil font-lock-type-face])
- (wisi-indent-action [nil nil ada-indent-broken nil ada-indent-broken
ada-indent-broken nil])))%
+ %((wisi-statement-action [1 statement-start 7 statement-end])
+ (wisi-name-action 3)
+ (wisi-face-apply-action [3 nil font-lock-type-face])
+ (wisi-indent-action [nil nil ada-indent-broken nil ada-indent-broken
ada-indent-broken nil]))%
;
;; LRM includes 'end identifier' here; we put that in
@@ -2506,9 +2392,8 @@ task_body_stub
;; actions.
task_definition
: declarative_part_opt PRIVATE declarative_part_opt
- %((progn
- (wisi-statement-action [2 motion])
- (wisi-indent-action [[ada-indent ada-indent] nil [ada-indent
ada-indent]])))%
+ %((wisi-statement-action [2 motion])
+ (wisi-indent-action [[ada-indent ada-indent] nil [ada-indent
ada-indent]]))%
| declarative_part_opt
%((wisi-indent-action [[ada-indent ada-indent]]))%
;
@@ -2518,30 +2403,27 @@ task_definition
task_type_declaration
: TASK TYPE IDENTIFIER discriminant_part_opt aspect_specification_opt IS
NEW interface_list WITH task_definition END identifier_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 6 motion 9 motion 13
statement-end])
- (wisi-name-action 3)
- (wisi-motion-action [1 6 9 [10 PRIVATE] 13])
- (wisi-face-apply-action [3 nil font-lock-type-face 12 nil
font-lock-type-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken nil nil
- ada-indent-broken ada-indent-broken
ada-indent-broken nil nil nil nil])))%
+ %((wisi-statement-action [1 statement-start 6 motion 9 motion 13
statement-end])
+ (wisi-name-action 3)
+ (wisi-motion-action [1 6 9 [10 PRIVATE] 13])
+ (wisi-face-apply-action [3 nil font-lock-type-face 12 nil
font-lock-type-face])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken nil nil
+ ada-indent-broken ada-indent-broken
ada-indent-broken nil nil nil nil]))%
%((wisi-match-names 3 12))%
| TASK TYPE IDENTIFIER discriminant_part_opt aspect_specification_opt IS
task_definition END identifier_opt SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 6 motion 10 statement-end])
- (wisi-name-action 3)
- (wisi-face-apply-action [3 nil font-lock-type-face 9 nil
font-lock-type-face])
- (wisi-motion-action [1 6 [7 PRIVATE] 10])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken nil [nil ada-indent] nil nil nil
- nil])))%
+ %((wisi-statement-action [1 statement-start 6 motion 10 statement-end])
+ (wisi-name-action 3)
+ (wisi-face-apply-action [3 nil font-lock-type-face 9 nil
font-lock-type-face])
+ (wisi-motion-action [1 6 [7 PRIVATE] 10])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken nil [nil ada-indent] nil nil nil
+ nil]))%
%((wisi-match-names 3 9))%
| TASK TYPE IDENTIFIER discriminant_part_opt aspect_specification_opt
SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 6 statement-end])
- (wisi-name-action 3)
- (wisi-face-apply-action [3 nil font-lock-type-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken nil nil])))%
+ %((wisi-statement-action [1 statement-start 6 statement-end])
+ (wisi-name-action 3)
+ (wisi-face-apply-action [3 nil font-lock-type-face])
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-broken nil nil]))%
;
term
@@ -2561,10 +2443,9 @@ tick
timed_entry_call
: SELECT entry_call_alternative OR delay_alternative END SELECT SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 3 motion 6 statement-end])
- (wisi-motion-action [1 3 6])
- (wisi-indent-action [nil [ada-indent ada-indent] nil [ada-indent
ada-indent] nil nil nil])))%
+ %((wisi-statement-action [1 statement-start 3 motion 6 statement-end])
+ (wisi-motion-action [1 3 6])
+ (wisi-indent-action [nil [ada-indent ada-indent] nil [ada-indent
ada-indent] nil nil nil]))%
;
triggering_alternative
@@ -2596,10 +2477,9 @@ type_definition
variant_part
: CASE direct_name_opt IS variant_list END CASE SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 7 statement-end])
- (wisi-motion-action [1 4 7])
- (wisi-indent-action [nil ada-indent-broken nil ada-indent-when nil nil
nil])))%
+ %((wisi-statement-action [1 statement-start 7 statement-end])
+ (wisi-motion-action [1 4 7])
+ (wisi-indent-action [nil ada-indent-broken nil ada-indent-when nil nil
nil]))%
;
variant_list
@@ -2610,53 +2490,45 @@ variant_list
variant
: WHEN discrete_choice_list EQUAL_GREATER component_list_opt
- %((progn
- (wisi-statement-action [1 motion])
+ %((wisi-statement-action [1 motion])
;; ada-indent-when applied in variant_part
- (wisi-indent-action [nil (wisi-hanging nil ada-indent-broken) ada-indent
[ada-indent ada-indent]])))%
+ (wisi-indent-action [nil (wisi-hanging nil ada-indent-broken) ada-indent
[ada-indent ada-indent]]))%
;
unary_adding_operator : PLUS | MINUS ; ;; + | -
use_clause
: USE ALL TYPE name_list SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 5 statement-end])
+ %((wisi-statement-action [1 statement-start 5 statement-end])
(wisi-face-apply-list-action [4 font-lock-function-name-face
font-lock-type-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-use nil])))%
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-use nil]))%
| USE TYPE name_list SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 4 statement-end])
+ %((wisi-statement-action [1 statement-start 4 statement-end])
(wisi-face-apply-list-action [3 font-lock-function-name-face
font-lock-type-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-use nil])))%
+ (wisi-indent-action [nil ada-indent-broken ada-indent-use nil]))%
| USE name_list SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 3 statement-end])
+ %((wisi-statement-action [1 statement-start 3 statement-end])
(wisi-face-apply-list-action [2 font-lock-function-name-face
font-lock-function-name-face])
- (wisi-indent-action [nil ada-indent-use nil])))%
+ (wisi-indent-action [nil ada-indent-use nil]))%
;
with_clause
: LIMITED PRIVATE WITH name_list SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 5 statement-end])
+ %((wisi-statement-action [1 statement-start 5 statement-end])
(wisi-face-apply-list-action [4 font-lock-function-name-face
font-lock-function-name-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-with nil])))%
+ (wisi-indent-action [nil ada-indent-broken ada-indent-broken
ada-indent-with nil]))%
| LIMITED WITH name_list SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 4 statement-end])
+ %((wisi-statement-action [1 statement-start 4 statement-end])
(wisi-face-apply-list-action [3 font-lock-function-name-face
font-lock-function-name-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-with nil])))%
+ (wisi-indent-action [nil ada-indent-broken ada-indent-with nil]))%
| PRIVATE WITH name_list SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 4 statement-end])
+ %((wisi-statement-action [1 statement-start 4 statement-end])
(wisi-face-apply-list-action [3 font-lock-function-name-face
font-lock-function-name-face])
- (wisi-indent-action [nil ada-indent-broken ada-indent-with nil])))%
+ (wisi-indent-action [nil ada-indent-broken ada-indent-with nil]))%
| WITH name_list SEMICOLON
- %((progn
- (wisi-statement-action [1 statement-start 3 statement-end])
+ %((wisi-statement-action [1 statement-start 3 statement-end])
(wisi-face-apply-list-action [2 font-lock-function-name-face
font-lock-function-name-face])
- (wisi-indent-action [nil ada-indent-with nil])))%
+ (wisi-indent-action [nil ada-indent-with nil]))%
;
;;; end of file
diff --git a/packages/ada-mode/ada_lr1_parse_table.txt.gz
b/packages/ada-mode/ada_lr1_parse_table.txt.gz
index 4192eb5..4ea747c 100644
Binary files a/packages/ada-mode/ada_lr1_parse_table.txt.gz and
b/packages/ada-mode/ada_lr1_parse_table.txt.gz differ
diff --git a/packages/ada-mode/ada_mode_wisi_parse.gpr.gp
b/packages/ada-mode/ada_mode_wisi_parse.gpr.gp
index 52b6503..95b3e16 100644
--- a/packages/ada-mode/ada_mode_wisi_parse.gpr.gp
+++ b/packages/ada-mode/ada_mode_wisi_parse.gpr.gp
@@ -2,7 +2,7 @@
--
-- build ada_mode_wisi_parse and other executables
--
--- Copyright (C) 2014, 2018 Free Software Foundation, Inc.
+-- Copyright (C) 2014, 2018, 2019 Free Software Foundation, Inc.
--
-- This program is free software; you can redistribute it and/or
-- modify it under terms of the GNU General Public License as
@@ -22,9 +22,15 @@ with "wisi";
with "wisitoken";
#end if;
with "standard_common";
-#if HAVE_LIBADALANG="yes"
-with "libadalang";
+with "gnatcoll";
+with "gnatcoll_sqlite";
+#if HAVE_GNATCOLL_XREF="yes"
+with "gnatcoll_xref";
#end if;
+with "gnat_util";
+-- #if HAVE_LIBADALANG="yes"
+-- with "libadalang";
+-- #end if;
project Ada_Mode_Wisi_Parse is
for Main use
@@ -32,11 +38,12 @@ project Ada_Mode_Wisi_Parse is
"ada_mode_wisi_lr1_parse.ads",
"run_ada_lalr_parse.ads",
"run_ada_lr1_parse.ads",
-#if HAVE_LIBADALANG="yes"
- "run_ada_libadalang_parse.ads",
-#end if;
+-- #if HAVE_LIBADALANG="yes"
+-- "run_ada_libadalang_parse.ads",
+-- #end if;
"gpr_mode_wisi_parse.ads",
- "run_gpr_parse.ads"
+ "run_gpr_parse.ads",
+ "gpr_query.adb"
);
for Source_Dirs use (".");
@@ -122,8 +129,6 @@ project Ada_Mode_Wisi_Parse is
for Global_Compilation_Switches ("Ada") use
Standard_Common.Builder'Global_Compilation_Switches ("Ada");
- -- We use ".exe" extension even on non-Windows, to simplify the
makefiles.
- for Executable_Suffix use ".exe";
end Builder;
package Binder is
diff --git a/packages/ada-mode/ada_process_actions.adb
b/packages/ada-mode/ada_process_actions.adb
index e59620b..10a0128 100644
--- a/packages/ada-mode/ada_process_actions.adb
+++ b/packages/ada-mode/ada_process_actions.adb
@@ -251,8 +251,9 @@ package body Ada_Process_Actions is
when Face =>
null;
when Indent =>
- Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple,
(Label => None))), (True, (Simple,
- (Anchored_0, 1, 1)), (Simple, (Anchored_0, 1, 1))), (False, (Simple,
(Anchored_0, 1, 0)))));
+ Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple,
(Label => None))), (False, (Simple,
+ (Anchored_0, 1, 1))), (False, (Simple, (Anchored_0, 1, 1))), (False,
(Simple, (Anchored_0, 1, 1))), (True,
+ (Simple, (Anchored_0, 1, 1)), (Simple, (Anchored_0, 1, 1))), (False,
(Simple, (Anchored_0, 1, 0)))));
end case;
end aggregate_3;
@@ -275,6 +276,25 @@ package body Ada_Process_Actions is
end case;
end aggregate_4;
+ procedure aggregate_5
+ (User_Data : in out WisiToken.Syntax_Trees.User_Data_Type'Class;
+ Tree : in out WisiToken.Syntax_Trees.Tree;
+ Nonterm : in WisiToken.Syntax_Trees.Valid_Node_Index;
+ Tokens : in WisiToken.Syntax_Trees.Valid_Node_Index_Array)
+ is
+ Parse_Data : Wisi.Parse_Data_Type renames Wisi.Parse_Data_Type
(User_Data);
+ begin
+ case Parse_Data.Post_Parse_Action is
+ when Navigate =>
+ null;
+ when Face =>
+ null;
+ when Indent =>
+ Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple,
(Label => None))), (True, (Simple,
+ (Anchored_0, 1, 1)), (Simple, (Anchored_0, 1, 1))), (False, (Simple,
(Anchored_0, 1, 0)))));
+ end case;
+ end aggregate_5;
+
procedure array_type_definition_0
(User_Data : in out WisiToken.Syntax_Trees.User_Data_Type'Class;
Tree : in out WisiToken.Syntax_Trees.Tree;
@@ -329,7 +349,9 @@ package body Ada_Process_Actions is
when Face =>
null;
when Indent =>
- null;
+ Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple,
(Label => None))), (False, (Simple,
+ (Int, Ada_Indent_Broken))), (False, (Simple, (Int,
Ada_Indent_Broken))), (False, (Simple, (Int,
+ Ada_Indent_Broken))), (False, (Simple, (Label => None)))));
end case;
end aspect_clause_0;
@@ -446,11 +468,32 @@ package body Ada_Process_Actions is
when Face =>
null;
when Indent =>
- Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, (1 => (True,
(Hanging_0, (Label => None), (Int,
+ Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple,
(Label => None))), (False, (Simple,
+ (Label => None))), (False, (Simple, (Label => None))), (False,
(Hanging_0, (Label => None), (Int,
+ Ada_Indent_Broken))), (False, (Simple, (Int, Ada_Indent_Broken))),
(True, (Hanging_0, (Label => None), (Int,
Ada_Indent_Broken)), (Hanging_0, (Label => None), (Int,
Ada_Indent_Broken)))));
end case;
end association_opt_4;
+ procedure association_opt_5
+ (User_Data : in out WisiToken.Syntax_Trees.User_Data_Type'Class;
+ Tree : in out WisiToken.Syntax_Trees.Tree;
+ Nonterm : in WisiToken.Syntax_Trees.Valid_Node_Index;
+ Tokens : in WisiToken.Syntax_Trees.Valid_Node_Index_Array)
+ is
+ Parse_Data : Wisi.Parse_Data_Type renames Wisi.Parse_Data_Type
(User_Data);
+ begin
+ case Parse_Data.Post_Parse_Action is
+ when Navigate =>
+ null;
+ when Face =>
+ null;
+ when Indent =>
+ Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, (1 => (True,
(Hanging_0, (Label => None), (Int,
+ Ada_Indent_Broken)), (Hanging_0, (Label => None), (Int,
Ada_Indent_Broken)))));
+ end case;
+ end association_opt_5;
+
procedure asynchronous_select_0
(User_Data : in out WisiToken.Syntax_Trees.User_Data_Type'Class;
Tree : in out WisiToken.Syntax_Trees.Tree;
@@ -659,8 +702,7 @@ package body Ada_Process_Actions is
when Face =>
null;
when Indent =>
- Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple,
(Label => None))), (True, (Simple,
- (Label => None)), (Simple, (Int, Ada_Indent_When))), (False, (Simple,
(Label => None)))));
+ null;
end case;
end case_expression_alternative_list_0;
@@ -969,7 +1011,10 @@ package body Ada_Process_Actions is
when Face =>
Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, (1 => (3, 1,
2)));
when Indent =>
- null;
+ Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple,
(Label => None))), (False, (Simple,
+ (Label => None))), (False, (Simple, (Label => None))), (False,
(Simple, (Label => None))), (True, (Simple,
+ (Label => None)), (Simple, (Language, Ada_Indent_Record_1'Access, 69
& 6 & 0))), (False, (Simple, (Label =>
+ None)))));
end case;
end derived_type_definition_0;
@@ -1769,9 +1814,9 @@ package body Ada_Process_Actions is
Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, (1 => (2, 3,
2)));
when Indent =>
Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple,
(Label => None))), (False, (Simple,
- (Int, Ada_Indent_Broken))), (False, (Simple, (Int,
Ada_Indent_Broken))), (False, (Simple, (Int,
- Ada_Indent_Broken))), (False, (Simple, (Int, Ada_Indent_Broken))),
(False, (Simple, (Label => None))), (False,
- (Simple, (Label => None)))));
+ (Int, Ada_Indent_Broken))), (False, (Simple, (Int,
Ada_Indent_Broken))), (True, (Simple, (Int,
+ Ada_Indent_Broken)), (Simple, (Language, Ada_Indent_Record_1'Access,
69 & 5 & Ada_Indent_Broken))), (False,
+ (Simple, (Int, Ada_Indent_Broken))), (False, (Simple, (Label =>
None))), (False, (Simple, (Label => None)))));
end case;
end full_type_declaration_0;
@@ -3877,11 +3922,12 @@ package body Ada_Process_Actions is
Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, (1 => (2, 1,
2)));
when Indent =>
Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple,
(Label => None))), (False, (Simple,
- (Int, Ada_Indent_Broken))), (False, (Simple, (Int,
Ada_Indent_Broken))), (False, (Simple, (Language,
- Ada_Indent_Record_0'Access, 1 & 4 & 0))), (False, (Simple, (Language,
Ada_Indent_Record_0'Access, 1 & 4 &
- Ada_Indent))), (False, (Simple, (Language,
Ada_Indent_Record_0'Access, 1 & 4 & Ada_Indent))), (False, (Simple,
- (Language, Ada_Indent_Record_0'Access, 1 & 4 & 0))), (False, (Simple,
(Label => None))), (False, (Simple,
- (Label => None)))));
+ (Int, Ada_Indent_Broken))), (False, (Simple, (Int,
Ada_Indent_Broken))), (True, (Simple, (Language,
+ Ada_Indent_Record_1'Access, 28 & 4 & 0)), (Simple, (Language,
Ada_Indent_Record_1'Access, 28 & 4 &
+ Ada_Indent))), (False, (Simple, (Language,
Ada_Indent_Record_0'Access, 1 & 4 & Ada_Indent))), (True, (Simple,
+ (Language, Ada_Indent_Record_1'Access, 28 & 4 & Ada_Indent)),
(Simple, (Language, Ada_Indent_Record_1'Access,
+ 28 & 4 & Ada_Indent))), (False, (Simple, (Language,
Ada_Indent_Record_1'Access, 28 & 4 & 0))), (False,
+ (Simple, (Label => None))), (False, (Simple, (Label => None)))));
end case;
end record_representation_clause_0;
diff --git a/packages/ada-mode/ada_process_actions.ads
b/packages/ada-mode/ada_process_actions.ads
index bb8a6bf..ab2ace3 100644
--- a/packages/ada-mode/ada_process_actions.ads
+++ b/packages/ada-mode/ada_process_actions.ads
@@ -24,15 +24,15 @@ package Ada_Process_Actions is
Descriptor : aliased WisiToken.Descriptor :=
(First_Terminal => 3,
- Last_Terminal => 107,
- First_Nonterminal => 108,
- Last_Nonterminal => 332,
- EOI_ID => 107,
- Accept_ID => 108,
+ Last_Terminal => 108,
+ First_Nonterminal => 109,
+ Last_Nonterminal => 333,
+ EOI_ID => 108,
+ Accept_ID => 109,
Case_Insensitive => True,
New_Line_ID => 1,
- String_1_ID => 106,
- String_2_ID => 105,
+ String_1_ID => 107,
+ String_2_ID => 106,
Image =>
(new String'("WHITESPACE"),
new String'("NEW_LINE"),
@@ -113,6 +113,7 @@ package Ada_Process_Actions is
new String'("LEFT_PAREN"),
new String'("RIGHT_PAREN"),
new String'("AMPERSAND"),
+ new String'("AT_SIGN"),
new String'("BAR"),
new String'("BOX"),
new String'("COLON"),
@@ -369,7 +370,7 @@ package Ada_Process_Actions is
new String'("with_clause")),
Terminal_Image_Width => 17,
Image_Width => 38,
- Last_Lookahead => 107);
+ Last_Lookahead => 108);
type Token_Enum_ID is
(WHITESPACE_ID,
@@ -451,6 +452,7 @@ package Ada_Process_Actions is
LEFT_PAREN_ID,
RIGHT_PAREN_ID,
AMPERSAND_ID,
+ AT_SIGN_ID,
BAR_ID,
BOX_ID,
COLON_ID,
@@ -774,6 +776,11 @@ package Ada_Process_Actions is
Tree : in out WisiToken.Syntax_Trees.Tree;
Nonterm : in WisiToken.Syntax_Trees.Valid_Node_Index;
Tokens : in WisiToken.Syntax_Trees.Valid_Node_Index_Array);
+ procedure aggregate_5
+ (User_Data : in out WisiToken.Syntax_Trees.User_Data_Type'Class;
+ Tree : in out WisiToken.Syntax_Trees.Tree;
+ Nonterm : in WisiToken.Syntax_Trees.Valid_Node_Index;
+ Tokens : in WisiToken.Syntax_Trees.Valid_Node_Index_Array);
procedure array_type_definition_0
(User_Data : in out WisiToken.Syntax_Trees.User_Data_Type'Class;
Tree : in out WisiToken.Syntax_Trees.Tree;
@@ -819,6 +826,11 @@ package Ada_Process_Actions is
Tree : in out WisiToken.Syntax_Trees.Tree;
Nonterm : in WisiToken.Syntax_Trees.Valid_Node_Index;
Tokens : in WisiToken.Syntax_Trees.Valid_Node_Index_Array);
+ procedure association_opt_5
+ (User_Data : in out WisiToken.Syntax_Trees.User_Data_Type'Class;
+ Tree : in out WisiToken.Syntax_Trees.Tree;
+ Nonterm : in WisiToken.Syntax_Trees.Valid_Node_Index;
+ Tokens : in WisiToken.Syntax_Trees.Valid_Node_Index_Array);
procedure asynchronous_select_0
(User_Data : in out WisiToken.Syntax_Trees.User_Data_Type'Class;
Tree : in out WisiToken.Syntax_Trees.Tree;
diff --git a/packages/ada-mode/ada_process_lalr_main.adb
b/packages/ada-mode/ada_process_lalr_main.adb
index 9d686df..9af10b0 100644
--- a/packages/ada-mode/ada_process_lalr_main.adb
+++ b/packages/ada-mode/ada_process_lalr_main.adb
@@ -39,17 +39,17 @@ package body Ada_Process_LALR_Main is
use WisiToken.Parse.LR;
McKenzie_Param : constant McKenzie_Param_Type :=
(First_Terminal => 3,
- Last_Terminal => 107,
- First_Nonterminal => 108,
- Last_Nonterminal => 332,
+ Last_Terminal => 108,
+ First_Nonterminal => 109,
+ Last_Nonterminal => 333,
Insert =>
(4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 4, 4, 4, 4, 4, 4, 4, 4, 3,
4, 4, 4, 4, 4, 4, 4, 2, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4),
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4),
Delete =>
(4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4),
+ 4, 4, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4),
Push_Back =>
(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
@@ -60,7 +60,7 @@ package body Ada_Process_LALR_Main is
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2),
+ 2, 2, 2, 2, 2, 2, 2),
Undo_Reduce =>
(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
@@ -80,40 +80,40 @@ package body Ada_Process_LALR_Main is
Table : constant Parse_Table_Ptr := new Parse_Table
(State_First => 0,
- State_Last => 1281,
+ State_Last => 1292,
First_Terminal => 3,
- Last_Terminal => 107,
- First_Nonterminal => 108,
- Last_Nonterminal => 332);
+ Last_Terminal => 108,
+ First_Nonterminal => 109,
+ Last_Nonterminal => 333);
begin
Table.McKenzie_Param := McKenzie_Param;
declare
procedure Subr_1
is begin
- Table.States (0).Action_List.Set_Capacity (38);
+ Table.States (0).Action_List.Set_Capacity (39);
Add_Action (Table.States (0), 4, 1);
Add_Action (Table.States (0), 5, 2);
- Add_Action (Table.States (0), 13, Reduce, (132, 1), 0, null, null);
+ Add_Action (Table.States (0), 13, Reduce, (133, 1), 0, null, null);
Add_Action (Table.States (0), 15, 3);
- Add_Action (Table.States (0), 17, Reduce, (132, 1), 0, null, null);
+ Add_Action (Table.States (0), 17, Reduce, (133, 1), 0, null, null);
Add_Action (Table.States (0), 18, 4);
- Add_Action (Table.States (0), 25, Reduce, (246, 2), 0, null, null);
+ Add_Action (Table.States (0), 25, Reduce, (247, 2), 0, null, null);
Add_Action (Table.States (0), 27, 5);
Add_Action (Table.States (0), 28, 6);
- Add_Conflict (Table.States (0), 28, (132, 1), 0, null, null);
- Add_Action (Table.States (0), 29, Reduce, (246, 2), 0, null, null);
+ Add_Conflict (Table.States (0), 28, (133, 1), 0, null, null);
+ Add_Action (Table.States (0), 29, Reduce, (247, 2), 0, null, null);
Add_Action (Table.States (0), 30, 8);
Add_Action (Table.States (0), 31, 9);
Add_Action (Table.States (0), 32, 10);
Add_Action (Table.States (0), 36, 11);
- Add_Action (Table.States (0), 37, Reduce, (132, 1), 0, null, null);
+ Add_Action (Table.States (0), 37, Reduce, (133, 1), 0, null, null);
Add_Action (Table.States (0), 40, 12);
Add_Action (Table.States (0), 41, 13);
Add_Action (Table.States (0), 46, 14);
Add_Action (Table.States (0), 47, 15);
Add_Action (Table.States (0), 48, 16);
Add_Action (Table.States (0), 49, 17);
- Add_Action (Table.States (0), 50, Reduce, (246, 2), 0, null, null);
+ Add_Action (Table.States (0), 50, Reduce, (247, 2), 0, null, null);
Add_Action (Table.States (0), 51, 19);
Add_Action (Table.States (0), 52, 20);
Add_Action (Table.States (0), 57, 21);
@@ -124,53 +124,53 @@ package body Ada_Process_LALR_Main is
Add_Action (Table.States (0), 66, 26);
Add_Action (Table.States (0), 69, 27);
Add_Action (Table.States (0), 71, 28);
- Add_Action (Table.States (0), 73, Reduce, (132, 1), 0, null, null);
+ Add_Action (Table.States (0), 73, Reduce, (133, 1), 0, null, null);
Add_Action (Table.States (0), 74, 30);
- Add_Action (Table.States (0), 93, 31);
- Add_Action (Table.States (0), 104, 32);
+ Add_Action (Table.States (0), 79, 31);
+ Add_Action (Table.States (0), 94, 32);
Add_Action (Table.States (0), 105, 33);
Add_Action (Table.States (0), 106, 34);
+ Add_Action (Table.States (0), 107, 35);
Table.States (0).Goto_List.Set_Capacity (83);
- Add_Goto (Table.States (0), 112, 35);
Add_Goto (Table.States (0), 113, 36);
- Add_Goto (Table.States (0), 121, 37);
- Add_Goto (Table.States (0), 123, 38);
- Add_Goto (Table.States (0), 126, 39);
+ Add_Goto (Table.States (0), 114, 37);
+ Add_Goto (Table.States (0), 122, 38);
+ Add_Goto (Table.States (0), 124, 39);
Add_Goto (Table.States (0), 127, 40);
Add_Goto (Table.States (0), 128, 41);
- Add_Goto (Table.States (0), 131, 42);
+ Add_Goto (Table.States (0), 129, 42);
Add_Goto (Table.States (0), 132, 43);
Add_Goto (Table.States (0), 133, 44);
Add_Goto (Table.States (0), 134, 45);
Add_Goto (Table.States (0), 135, 46);
- Add_Goto (Table.States (0), 139, 47);
- Add_Goto (Table.States (0), 142, 48);
+ Add_Goto (Table.States (0), 136, 47);
+ Add_Goto (Table.States (0), 140, 48);
Add_Goto (Table.States (0), 143, 49);
- Add_Goto (Table.States (0), 151, 50);
+ Add_Goto (Table.States (0), 144, 50);
Add_Goto (Table.States (0), 152, 51);
- Add_Goto (Table.States (0), 157, 52);
- Add_Goto (Table.States (0), 161, 53);
- Add_Goto (Table.States (0), 179, 54);
- Add_Goto (Table.States (0), 182, 55);
- Add_Goto (Table.States (0), 186, 56);
- Add_Goto (Table.States (0), 190, 57);
- Add_Goto (Table.States (0), 193, 58);
- Add_Goto (Table.States (0), 196, 59);
- Add_Goto (Table.States (0), 206, 60);
+ Add_Goto (Table.States (0), 153, 52);
+ Add_Goto (Table.States (0), 158, 53);
+ Add_Goto (Table.States (0), 162, 54);
+ Add_Goto (Table.States (0), 180, 55);
+ Add_Goto (Table.States (0), 183, 56);
+ Add_Goto (Table.States (0), 187, 57);
+ Add_Goto (Table.States (0), 191, 58);
+ Add_Goto (Table.States (0), 194, 59);
+ Add_Goto (Table.States (0), 197, 60);
Add_Goto (Table.States (0), 207, 61);
- Add_Goto (Table.States (0), 209, 62);
+ Add_Goto (Table.States (0), 208, 62);
Add_Goto (Table.States (0), 210, 63);
- Add_Goto (Table.States (0), 213, 64);
+ Add_Goto (Table.States (0), 211, 64);
Add_Goto (Table.States (0), 214, 65);
Add_Goto (Table.States (0), 215, 66);
Add_Goto (Table.States (0), 216, 67);
Add_Goto (Table.States (0), 217, 68);
- Add_Goto (Table.States (0), 219, 69);
- Add_Goto (Table.States (0), 222, 70);
+ Add_Goto (Table.States (0), 218, 69);
+ Add_Goto (Table.States (0), 220, 70);
Add_Goto (Table.States (0), 223, 71);
- Add_Goto (Table.States (0), 232, 72);
- Add_Goto (Table.States (0), 239, 73);
- Add_Goto (Table.States (0), 243, 74);
+ Add_Goto (Table.States (0), 224, 72);
+ Add_Goto (Table.States (0), 233, 73);
+ Add_Goto (Table.States (0), 240, 74);
Add_Goto (Table.States (0), 244, 75);
Add_Goto (Table.States (0), 245, 76);
Add_Goto (Table.States (0), 246, 77);
@@ -179,24 +179,24 @@ package body Ada_Process_LALR_Main is
Add_Goto (Table.States (0), 249, 80);
Add_Goto (Table.States (0), 250, 81);
Add_Goto (Table.States (0), 251, 82);
- Add_Goto (Table.States (0), 257, 83);
- Add_Goto (Table.States (0), 259, 84);
+ Add_Goto (Table.States (0), 252, 83);
+ Add_Goto (Table.States (0), 258, 84);
Add_Goto (Table.States (0), 260, 85);
Add_Goto (Table.States (0), 261, 86);
Add_Goto (Table.States (0), 262, 87);
Add_Goto (Table.States (0), 263, 88);
Add_Goto (Table.States (0), 264, 89);
Add_Goto (Table.States (0), 265, 90);
- Add_Goto (Table.States (0), 271, 91);
+ Add_Goto (Table.States (0), 266, 91);
Add_Goto (Table.States (0), 272, 92);
- Add_Goto (Table.States (0), 276, 93);
- Add_Goto (Table.States (0), 281, 94);
- Add_Goto (Table.States (0), 289, 95);
+ Add_Goto (Table.States (0), 273, 93);
+ Add_Goto (Table.States (0), 277, 94);
+ Add_Goto (Table.States (0), 282, 95);
Add_Goto (Table.States (0), 290, 96);
- Add_Goto (Table.States (0), 293, 97);
+ Add_Goto (Table.States (0), 291, 97);
Add_Goto (Table.States (0), 294, 98);
- Add_Goto (Table.States (0), 298, 99);
- Add_Goto (Table.States (0), 302, 100);
+ Add_Goto (Table.States (0), 295, 99);
+ Add_Goto (Table.States (0), 299, 100);
Add_Goto (Table.States (0), 303, 101);
Add_Goto (Table.States (0), 304, 102);
Add_Goto (Table.States (0), 305, 103);
@@ -204,280 +204,287 @@ package body Ada_Process_LALR_Main is
Add_Goto (Table.States (0), 307, 105);
Add_Goto (Table.States (0), 308, 106);
Add_Goto (Table.States (0), 309, 107);
- Add_Goto (Table.States (0), 311, 108);
- Add_Goto (Table.States (0), 313, 109);
- Add_Goto (Table.States (0), 315, 110);
+ Add_Goto (Table.States (0), 310, 108);
+ Add_Goto (Table.States (0), 312, 109);
+ Add_Goto (Table.States (0), 314, 110);
Add_Goto (Table.States (0), 316, 111);
Add_Goto (Table.States (0), 317, 112);
- Add_Goto (Table.States (0), 319, 113);
- Add_Goto (Table.States (0), 323, 114);
- Add_Goto (Table.States (0), 325, 115);
- Add_Goto (Table.States (0), 331, 116);
+ Add_Goto (Table.States (0), 318, 113);
+ Add_Goto (Table.States (0), 320, 114);
+ Add_Goto (Table.States (0), 324, 115);
+ Add_Goto (Table.States (0), 326, 116);
Add_Goto (Table.States (0), 332, 117);
+ Add_Goto (Table.States (0), 333, 118);
Table.States (0).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 41, 13)));
Table.States (1).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1), 104, 118);
- Table.States (1).Kernel := To_Vector (((113, 4, 4, False), (113,
4, 2, False)));
- Table.States (1).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 118)));
- Table.States (2).Action_List.Set_Capacity (3);
- Add_Action (Table.States (2), 104, 119);
- Add_Action (Table.States (2), 105, 33);
+ Add_Action (Table.States (1), 105, 119);
+ Table.States (1).Kernel := To_Vector (((114, 4, 4, False), (114,
4, 2, False)));
+ Table.States (1).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 119)));
+ Table.States (2).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (2), 79, 31);
+ Add_Action (Table.States (2), 105, 120);
Add_Action (Table.States (2), 106, 34);
+ Add_Action (Table.States (2), 107, 35);
Table.States (2).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (2), 128, 41);
- Add_Goto (Table.States (2), 239, 120);
- Add_Goto (Table.States (2), 272, 92);
- Add_Goto (Table.States (2), 293, 97);
- Table.States (2).Kernel := To_Vector ((0 => (303, 5, 2, False)));
- Table.States (2).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (3).Action_List.Set_Capacity (13);
- Add_Action (Table.States (3), 3, 121);
- Add_Action (Table.States (3), 35, Reduce, (192, 1), 0, null, null);
- Add_Action (Table.States (3), 39, 122);
- Add_Action (Table.States (3), 40, 123);
- Add_Action (Table.States (3), 41, 124);
- Add_Action (Table.States (3), 52, 125);
- Add_Action (Table.States (3), 76, 126);
- Add_Action (Table.States (3), 94, 127);
+ Add_Goto (Table.States (2), 129, 42);
+ Add_Goto (Table.States (2), 240, 121);
+ Add_Goto (Table.States (2), 273, 93);
+ Add_Goto (Table.States (2), 294, 98);
+ Table.States (2).Kernel := To_Vector ((0 => (304, 5, 2, False)));
+ Table.States (2).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (3).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (3), 3, 122);
+ Add_Action (Table.States (3), 35, Reduce, (193, 1), 0, null, null);
+ Add_Action (Table.States (3), 39, 123);
+ Add_Action (Table.States (3), 40, 124);
+ Add_Action (Table.States (3), 41, 125);
+ Add_Action (Table.States (3), 52, 126);
+ Add_Action (Table.States (3), 76, 127);
+ Add_Action (Table.States (3), 79, 31);
Add_Action (Table.States (3), 95, 128);
- Add_Action (Table.States (3), 103, 129);
- Add_Action (Table.States (3), 104, 119);
- Add_Action (Table.States (3), 105, 33);
+ Add_Action (Table.States (3), 96, 129);
+ Add_Action (Table.States (3), 104, 130);
+ Add_Action (Table.States (3), 105, 120);
Add_Action (Table.States (3), 106, 34);
+ Add_Action (Table.States (3), 107, 35);
Table.States (3).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (3), 117, 130);
- Add_Goto (Table.States (3), 128, 41);
- Add_Goto (Table.States (3), 191, 131);
+ Add_Goto (Table.States (3), 118, 131);
+ Add_Goto (Table.States (3), 129, 42);
Add_Goto (Table.States (3), 192, 132);
- Add_Goto (Table.States (3), 197, 133);
- Add_Goto (Table.States (3), 239, 134);
- Add_Goto (Table.States (3), 258, 135);
- Add_Goto (Table.States (3), 272, 92);
- Add_Goto (Table.States (3), 275, 136);
- Add_Goto (Table.States (3), 282, 137);
+ Add_Goto (Table.States (3), 193, 133);
+ Add_Goto (Table.States (3), 198, 134);
+ Add_Goto (Table.States (3), 240, 135);
+ Add_Goto (Table.States (3), 259, 136);
+ Add_Goto (Table.States (3), 273, 93);
+ Add_Goto (Table.States (3), 276, 137);
Add_Goto (Table.States (3), 283, 138);
Add_Goto (Table.States (3), 284, 139);
Add_Goto (Table.States (3), 285, 140);
Add_Goto (Table.States (3), 286, 141);
Add_Goto (Table.States (3), 287, 142);
- Add_Goto (Table.States (3), 293, 97);
- Add_Goto (Table.States (3), 301, 143);
- Add_Goto (Table.States (3), 320, 144);
+ Add_Goto (Table.States (3), 288, 143);
+ Add_Goto (Table.States (3), 294, 98);
+ Add_Goto (Table.States (3), 302, 144);
Add_Goto (Table.States (3), 321, 145);
- Add_Goto (Table.States (3), 330, 146);
- Table.States (3).Kernel := To_Vector ((0 => (139, 15, 6, False)));
- Table.States (3).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (4).Action_List.Set_Capacity (14);
- Add_Action (Table.States (4), 3, 121);
- Add_Action (Table.States (4), 39, 122);
- Add_Action (Table.States (4), 40, 123);
- Add_Action (Table.States (4), 41, 124);
- Add_Action (Table.States (4), 52, 125);
- Add_Action (Table.States (4), 70, 147);
- Add_Action (Table.States (4), 76, 126);
- Add_Action (Table.States (4), 94, 127);
+ Add_Goto (Table.States (3), 322, 146);
+ Add_Goto (Table.States (3), 331, 147);
+ Table.States (3).Kernel := To_Vector ((0 => (140, 15, 6, False)));
+ Table.States (3).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (4).Action_List.Set_Capacity (15);
+ Add_Action (Table.States (4), 3, 122);
+ Add_Action (Table.States (4), 39, 123);
+ Add_Action (Table.States (4), 40, 124);
+ Add_Action (Table.States (4), 41, 125);
+ Add_Action (Table.States (4), 52, 126);
+ Add_Action (Table.States (4), 70, 148);
+ Add_Action (Table.States (4), 76, 127);
+ Add_Action (Table.States (4), 79, 31);
Add_Action (Table.States (4), 95, 128);
- Add_Action (Table.States (4), 96, Reduce, (192, 1), 0, null, null);
- Add_Action (Table.States (4), 103, 129);
- Add_Action (Table.States (4), 104, 119);
- Add_Action (Table.States (4), 105, 33);
+ Add_Action (Table.States (4), 96, 129);
+ Add_Action (Table.States (4), 97, Reduce, (193, 1), 0, null, null);
+ Add_Action (Table.States (4), 104, 130);
+ Add_Action (Table.States (4), 105, 120);
Add_Action (Table.States (4), 106, 34);
+ Add_Action (Table.States (4), 107, 35);
Table.States (4).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (4), 117, 130);
- Add_Goto (Table.States (4), 128, 41);
- Add_Goto (Table.States (4), 191, 131);
- Add_Goto (Table.States (4), 192, 148);
- Add_Goto (Table.States (4), 197, 133);
- Add_Goto (Table.States (4), 239, 134);
- Add_Goto (Table.States (4), 258, 135);
- Add_Goto (Table.States (4), 272, 92);
- Add_Goto (Table.States (4), 275, 136);
- Add_Goto (Table.States (4), 282, 137);
+ Add_Goto (Table.States (4), 118, 131);
+ Add_Goto (Table.States (4), 129, 42);
+ Add_Goto (Table.States (4), 192, 132);
+ Add_Goto (Table.States (4), 193, 149);
+ Add_Goto (Table.States (4), 198, 134);
+ Add_Goto (Table.States (4), 240, 135);
+ Add_Goto (Table.States (4), 259, 136);
+ Add_Goto (Table.States (4), 273, 93);
+ Add_Goto (Table.States (4), 276, 137);
Add_Goto (Table.States (4), 283, 138);
Add_Goto (Table.States (4), 284, 139);
Add_Goto (Table.States (4), 285, 140);
Add_Goto (Table.States (4), 286, 141);
Add_Goto (Table.States (4), 287, 142);
- Add_Goto (Table.States (4), 293, 97);
- Add_Goto (Table.States (4), 301, 143);
- Add_Goto (Table.States (4), 320, 144);
+ Add_Goto (Table.States (4), 288, 143);
+ Add_Goto (Table.States (4), 294, 98);
+ Add_Goto (Table.States (4), 302, 144);
Add_Goto (Table.States (4), 321, 145);
- Add_Goto (Table.States (4), 330, 146);
- Table.States (4).Kernel := To_Vector (((161, 18, 2, False), (161,
18, 1, False)));
- Table.States (4).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
+ Add_Goto (Table.States (4), 322, 146);
+ Add_Goto (Table.States (4), 331, 147);
+ Table.States (4).Kernel := To_Vector (((162, 18, 2, False), (162,
18, 1, False)));
+ Table.States (4).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
Table.States (5).Action_List.Set_Capacity (3);
- Add_Action (Table.States (5), 72, Reduce, (220, 1), 0, null, null);
- Add_Action (Table.States (5), 96, Reduce, (220, 1), 0, null, null);
- Add_Action (Table.States (5), 104, 149);
+ Add_Action (Table.States (5), 72, Reduce, (221, 1), 0, null, null);
+ Add_Action (Table.States (5), 97, Reduce, (221, 1), 0, null, null);
+ Add_Action (Table.States (5), 105, 150);
Table.States (5).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (5), 220, 150);
- Table.States (5).Kernel := To_Vector (((190, 27, 2, False), (190,
27, 1, False)));
- Table.States (5).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 220, 0)));
- Table.States (6).Action_List.Set_Capacity (3);
- Add_Action (Table.States (6), 104, 151);
+ Add_Goto (Table.States (5), 221, 151);
+ Table.States (5).Kernel := To_Vector (((191, 27, 2, False), (191,
27, 1, False)));
+ Table.States (5).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 221, 0)));
+ Table.States (6).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (6), 79, 31);
Add_Action (Table.States (6), 105, 152);
- Add_Action (Table.States (6), 106, 34);
+ Add_Action (Table.States (6), 106, 153);
+ Add_Action (Table.States (6), 107, 35);
Table.States (6).Goto_List.Set_Capacity (7);
- Add_Goto (Table.States (6), 128, 153);
- Add_Goto (Table.States (6), 163, 154);
- Add_Goto (Table.States (6), 230, 155);
+ Add_Goto (Table.States (6), 129, 154);
+ Add_Goto (Table.States (6), 164, 155);
Add_Goto (Table.States (6), 231, 156);
- Add_Goto (Table.States (6), 239, 157);
- Add_Goto (Table.States (6), 272, 92);
- Add_Goto (Table.States (6), 293, 97);
- Table.States (6).Kernel := To_Vector (((121, 28, 5, False), (127,
28, 4, False), (182, 28, 5, False), (229,
- 28, 0, False), (281, 28, 14, False)));
- Table.States (6).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 231, 0)));
- Table.States (7).Action_List.Set_Capacity (3);
- Add_Action (Table.States (7), 104, 119);
- Add_Action (Table.States (7), 105, 33);
+ Add_Goto (Table.States (6), 232, 157);
+ Add_Goto (Table.States (6), 240, 158);
+ Add_Goto (Table.States (6), 273, 93);
+ Add_Goto (Table.States (6), 294, 98);
+ Table.States (6).Kernel := To_Vector (((122, 28, 5, False), (128,
28, 4, False), (183, 28, 5, False), (230,
+ 28, 0, False), (282, 28, 14, False)));
+ Table.States (6).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 232, 0)));
+ Table.States (7).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (7), 79, 31);
+ Add_Action (Table.States (7), 105, 120);
Add_Action (Table.States (7), 106, 34);
+ Add_Action (Table.States (7), 107, 35);
Table.States (7).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (7), 128, 41);
- Add_Goto (Table.States (7), 239, 158);
- Add_Goto (Table.States (7), 272, 92);
- Add_Goto (Table.States (7), 293, 97);
- Table.States (7).Kernel := To_Vector ((0 => (207, 29, 2, False)));
- Table.States (7).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
+ Add_Goto (Table.States (7), 129, 42);
+ Add_Goto (Table.States (7), 240, 159);
+ Add_Goto (Table.States (7), 273, 93);
+ Add_Goto (Table.States (7), 294, 98);
+ Table.States (7).Kernel := To_Vector ((0 => (208, 29, 2, False)));
+ Table.States (7).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
Table.States (8).Action_List.Set_Capacity (8);
- Add_Action (Table.States (8), 29, 159);
- Add_Conflict (Table.States (8), 29, (210, 1), 1,
generic_formal_part_1'Access, null);
- Add_Action (Table.States (8), 47, 160);
- Add_Conflict (Table.States (8), 47, (210, 1), 1,
generic_formal_part_1'Access, null);
+ Add_Action (Table.States (8), 29, 160);
+ Add_Conflict (Table.States (8), 29, (211, 1), 1,
generic_formal_part_1'Access, null);
+ Add_Action (Table.States (8), 47, 161);
+ Add_Conflict (Table.States (8), 47, (211, 1), 1,
generic_formal_part_1'Access, null);
Add_Action (Table.States (8), 48, 16);
- Add_Action (Table.States (8), 50, 161);
- Add_Conflict (Table.States (8), 50, (210, 1), 1,
generic_formal_part_1'Access, null);
- Add_Action (Table.States (8), 69, 162);
+ Add_Action (Table.States (8), 50, 162);
+ Add_Conflict (Table.States (8), 50, (211, 1), 1,
generic_formal_part_1'Access, null);
+ Add_Action (Table.States (8), 69, 163);
Add_Action (Table.States (8), 71, 28);
- Add_Action (Table.States (8), 74, 163);
- Add_Action (Table.States (8), 104, 164);
+ Add_Action (Table.States (8), 74, 164);
+ Add_Action (Table.States (8), 105, 165);
Table.States (8).Goto_List.Set_Capacity (9);
- Add_Goto (Table.States (8), 198, 165);
- Add_Goto (Table.States (8), 200, 166);
+ Add_Goto (Table.States (8), 199, 166);
Add_Goto (Table.States (8), 201, 167);
- Add_Goto (Table.States (8), 204, 168);
- Add_Goto (Table.States (8), 211, 169);
+ Add_Goto (Table.States (8), 202, 168);
+ Add_Goto (Table.States (8), 205, 169);
Add_Goto (Table.States (8), 212, 170);
- Add_Goto (Table.States (8), 219, 171);
- Add_Goto (Table.States (8), 257, 172);
- Add_Goto (Table.States (8), 331, 173);
- Table.States (8).Kernel := To_Vector (((210, 30, 3, False), (210,
30, 0, False), (215, 30, 5, False), (215,
- 30, 5, False), (215, 30, 5, False)));
- Table.States (8).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 210, 1)));
+ Add_Goto (Table.States (8), 213, 171);
+ Add_Goto (Table.States (8), 220, 172);
+ Add_Goto (Table.States (8), 258, 173);
+ Add_Goto (Table.States (8), 332, 174);
+ Table.States (8).Kernel := To_Vector (((211, 30, 3, False), (211,
30, 0, False), (216, 30, 5, False), (216,
+ 30, 5, False), (216, 30, 5, False)));
+ Table.States (8).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 211, 1)));
Table.States (9).Action_List.Set_Capacity (1);
- Add_Action (Table.States (9), 104, 174);
- Table.States (9).Kernel := To_Vector ((0 => (303, 31, 2, False)));
- Table.States (9).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 174)));
- Table.States (10).Action_List.Set_Capacity (13);
- Add_Action (Table.States (10), 3, 121);
- Add_Action (Table.States (10), 39, 122);
- Add_Action (Table.States (10), 40, 123);
- Add_Action (Table.States (10), 41, 124);
- Add_Action (Table.States (10), 52, 125);
- Add_Action (Table.States (10), 68, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (10), 76, 126);
- Add_Action (Table.States (10), 94, 127);
+ Add_Action (Table.States (9), 105, 175);
+ Table.States (9).Kernel := To_Vector ((0 => (304, 31, 2, False)));
+ Table.States (9).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 175)));
+ Table.States (10).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (10), 3, 122);
+ Add_Action (Table.States (10), 39, 123);
+ Add_Action (Table.States (10), 40, 124);
+ Add_Action (Table.States (10), 41, 125);
+ Add_Action (Table.States (10), 52, 126);
+ Add_Action (Table.States (10), 68, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (10), 76, 127);
+ Add_Action (Table.States (10), 79, 31);
Add_Action (Table.States (10), 95, 128);
- Add_Action (Table.States (10), 103, 129);
- Add_Action (Table.States (10), 104, 119);
- Add_Action (Table.States (10), 105, 33);
+ Add_Action (Table.States (10), 96, 129);
+ Add_Action (Table.States (10), 104, 130);
+ Add_Action (Table.States (10), 105, 120);
Add_Action (Table.States (10), 106, 34);
+ Add_Action (Table.States (10), 107, 35);
Table.States (10).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (10), 117, 130);
- Add_Goto (Table.States (10), 128, 41);
- Add_Goto (Table.States (10), 191, 131);
- Add_Goto (Table.States (10), 192, 175);
- Add_Goto (Table.States (10), 197, 133);
- Add_Goto (Table.States (10), 239, 134);
- Add_Goto (Table.States (10), 258, 135);
- Add_Goto (Table.States (10), 272, 92);
- Add_Goto (Table.States (10), 275, 136);
- Add_Goto (Table.States (10), 282, 137);
+ Add_Goto (Table.States (10), 118, 131);
+ Add_Goto (Table.States (10), 129, 42);
+ Add_Goto (Table.States (10), 192, 132);
+ Add_Goto (Table.States (10), 193, 176);
+ Add_Goto (Table.States (10), 198, 134);
+ Add_Goto (Table.States (10), 240, 135);
+ Add_Goto (Table.States (10), 259, 136);
+ Add_Goto (Table.States (10), 273, 93);
+ Add_Goto (Table.States (10), 276, 137);
Add_Goto (Table.States (10), 283, 138);
Add_Goto (Table.States (10), 284, 139);
Add_Goto (Table.States (10), 285, 140);
Add_Goto (Table.States (10), 286, 141);
Add_Goto (Table.States (10), 287, 142);
- Add_Goto (Table.States (10), 293, 97);
- Add_Goto (Table.States (10), 301, 143);
- Add_Goto (Table.States (10), 320, 144);
+ Add_Goto (Table.States (10), 288, 143);
+ Add_Goto (Table.States (10), 294, 98);
+ Add_Goto (Table.States (10), 302, 144);
Add_Goto (Table.States (10), 321, 145);
- Add_Goto (Table.States (10), 330, 146);
- Table.States (10).Kernel := To_Vector (((222, 32, 7, False), (222,
32, 5, False), (222, 32, 6, False),
- (222, 32, 4, False)));
- Table.States (10).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
+ Add_Goto (Table.States (10), 322, 146);
+ Add_Goto (Table.States (10), 331, 147);
+ Table.States (10).Kernel := To_Vector (((223, 32, 7, False), (223,
32, 5, False), (223, 32, 6, False),
+ (223, 32, 4, False)));
+ Table.States (10).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
Table.States (11).Action_List.Set_Capacity (2);
- Add_Action (Table.States (11), 49, 176);
- Add_Action (Table.States (11), 74, 177);
- Table.States (11).Kernel := To_Vector (((332, 36, 4, False), (332,
36, 3, False)));
- Table.States (11).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 74, 177)));
+ Add_Action (Table.States (11), 49, 177);
+ Add_Action (Table.States (11), 74, 178);
+ Table.States (11).Kernel := To_Vector (((333, 36, 4, False), (333,
36, 3, False)));
+ Table.States (11).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 74, 178)));
Table.States (12).Action_List.Set_Capacity (1);
- Add_Action (Table.States (12), 46, 178);
- Table.States (12).Kernel := To_Vector ((0 => (246, 40, 1, False)));
- Table.States (12).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 46, 178)));
+ Add_Action (Table.States (12), 46, 179);
+ Table.States (12).Kernel := To_Vector ((0 => (247, 40, 1, False)));
+ Table.States (12).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 46, 179)));
Table.States (13).Action_List.Set_Capacity (1);
- Add_Action (Table.States (13), 96, 179);
- Table.States (13).Kernel := To_Vector ((0 => (303, 41, 1, False)));
- Table.States (13).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 179)));
+ Add_Action (Table.States (13), 97, 180);
+ Table.States (13).Kernel := To_Vector ((0 => (304, 41, 1, False)));
+ Table.States (13).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 180)));
Table.States (14).Action_List.Set_Capacity (3);
- Add_Action (Table.States (14), (25, 29, 50), (246, 1), 1,
overriding_indicator_opt_1'Access, null);
- Table.States (14).Kernel := To_Vector ((0 => (246, 46, 0, False)));
- Table.States (14).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 246, 1)));
- Table.States (15).Action_List.Set_Capacity (4);
- Add_Action (Table.States (15), 14, 180);
- Add_Action (Table.States (15), 104, 119);
- Add_Action (Table.States (15), 105, 33);
+ Add_Action (Table.States (14), (25, 29, 50), (247, 1), 1,
overriding_indicator_opt_1'Access, null);
+ Table.States (14).Kernel := To_Vector ((0 => (247, 46, 0, False)));
+ Table.States (14).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 247, 1)));
+ Table.States (15).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (15), 14, 181);
+ Add_Action (Table.States (15), 79, 31);
+ Add_Action (Table.States (15), 105, 120);
Add_Action (Table.States (15), 106, 34);
+ Add_Action (Table.States (15), 107, 35);
Table.States (15).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (15), 128, 41);
- Add_Goto (Table.States (15), 239, 181);
- Add_Goto (Table.States (15), 272, 92);
- Add_Goto (Table.States (15), 293, 97);
- Table.States (15).Kernel := To_Vector (((213, 47, 5, False), (247,
47, 6, False), (247, 47, 5, False),
- (248, 47, 5, False), (250, 47, 4, False), (251, 47, 4, False),
(251, 47, 3, False)));
- Table.States (15).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
+ Add_Goto (Table.States (15), 129, 42);
+ Add_Goto (Table.States (15), 240, 182);
+ Add_Goto (Table.States (15), 273, 93);
+ Add_Goto (Table.States (15), 294, 98);
+ Table.States (15).Kernel := To_Vector (((214, 47, 5, False), (248,
47, 6, False), (248, 47, 5, False),
+ (249, 47, 5, False), (251, 47, 4, False), (252, 47, 4, False),
(252, 47, 3, False)));
+ Table.States (15).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
Table.States (16).Action_List.Set_Capacity (1);
- Add_Action (Table.States (16), 104, 182);
- Table.States (16).Kernel := To_Vector (((257, 48, 4, False), (257,
48, 6, False), (257, 48, 2, False)));
- Table.States (16).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 182)));
+ Add_Action (Table.States (16), 105, 183);
+ Table.States (16).Kernel := To_Vector (((258, 48, 4, False), (258,
48, 6, False), (258, 48, 2, False)));
+ Table.States (16).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 183)));
Table.States (17).Action_List.Set_Capacity (15);
- Add_Action (Table.States (17), 25, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (17), 28, 183);
- Add_Action (Table.States (17), 29, Reduce, (246, 2), 0, null,
null);
+ Add_Action (Table.States (17), 25, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (17), 28, 184);
+ Add_Action (Table.States (17), 29, Reduce, (247, 2), 0, null,
null);
Add_Action (Table.States (17), 30, 8);
Add_Action (Table.States (17), 40, 12);
Add_Action (Table.States (17), 46, 14);
Add_Action (Table.States (17), 47, 15);
- Add_Action (Table.States (17), 50, Reduce, (246, 2), 0, null,
null);
+ Add_Action (Table.States (17), 50, Reduce, (247, 2), 0, null,
null);
Add_Action (Table.States (17), 51, 19);
Add_Action (Table.States (17), 63, 25);
Add_Action (Table.States (17), 66, 26);
Add_Action (Table.States (17), 69, 27);
Add_Action (Table.States (17), 71, 28);
- Add_Action (Table.States (17), 74, 184);
- Add_Action (Table.States (17), 104, 185);
+ Add_Action (Table.States (17), 74, 185);
+ Add_Action (Table.States (17), 105, 186);
Table.States (17).Goto_List.Set_Capacity (50);
- Add_Goto (Table.States (17), 112, 35);
- Add_Goto (Table.States (17), 121, 37);
- Add_Goto (Table.States (17), 127, 40);
- Add_Goto (Table.States (17), 134, 45);
+ Add_Goto (Table.States (17), 113, 36);
+ Add_Goto (Table.States (17), 122, 38);
+ Add_Goto (Table.States (17), 128, 41);
Add_Goto (Table.States (17), 135, 46);
- Add_Goto (Table.States (17), 157, 186);
- Add_Goto (Table.States (17), 179, 54);
- Add_Goto (Table.States (17), 182, 55);
- Add_Goto (Table.States (17), 186, 56);
- Add_Goto (Table.States (17), 193, 58);
- Add_Goto (Table.States (17), 206, 60);
+ Add_Goto (Table.States (17), 136, 47);
+ Add_Goto (Table.States (17), 158, 187);
+ Add_Goto (Table.States (17), 180, 55);
+ Add_Goto (Table.States (17), 183, 56);
+ Add_Goto (Table.States (17), 187, 57);
+ Add_Goto (Table.States (17), 194, 59);
Add_Goto (Table.States (17), 207, 61);
- Add_Goto (Table.States (17), 209, 62);
+ Add_Goto (Table.States (17), 208, 62);
Add_Goto (Table.States (17), 210, 63);
- Add_Goto (Table.States (17), 213, 64);
+ Add_Goto (Table.States (17), 211, 64);
Add_Goto (Table.States (17), 214, 65);
Add_Goto (Table.States (17), 215, 66);
Add_Goto (Table.States (17), 216, 67);
- Add_Goto (Table.States (17), 219, 69);
- Add_Goto (Table.States (17), 223, 71);
- Add_Goto (Table.States (17), 243, 74);
+ Add_Goto (Table.States (17), 217, 68);
+ Add_Goto (Table.States (17), 220, 70);
+ Add_Goto (Table.States (17), 224, 72);
Add_Goto (Table.States (17), 244, 75);
Add_Goto (Table.States (17), 245, 76);
Add_Goto (Table.States (17), 246, 77);
@@ -486,14877 +493,15280 @@ package body Ada_Process_LALR_Main is
Add_Goto (Table.States (17), 249, 80);
Add_Goto (Table.States (17), 250, 81);
Add_Goto (Table.States (17), 251, 82);
- Add_Goto (Table.States (17), 259, 84);
+ Add_Goto (Table.States (17), 252, 83);
Add_Goto (Table.States (17), 260, 85);
- Add_Goto (Table.States (17), 262, 87);
+ Add_Goto (Table.States (17), 261, 86);
Add_Goto (Table.States (17), 263, 88);
Add_Goto (Table.States (17), 264, 89);
Add_Goto (Table.States (17), 265, 90);
- Add_Goto (Table.States (17), 271, 91);
- Add_Goto (Table.States (17), 281, 94);
- Add_Goto (Table.States (17), 289, 95);
- Add_Goto (Table.States (17), 304, 102);
+ Add_Goto (Table.States (17), 266, 91);
+ Add_Goto (Table.States (17), 272, 92);
+ Add_Goto (Table.States (17), 282, 95);
+ Add_Goto (Table.States (17), 290, 96);
Add_Goto (Table.States (17), 305, 103);
- Add_Goto (Table.States (17), 307, 105);
+ Add_Goto (Table.States (17), 306, 104);
Add_Goto (Table.States (17), 308, 106);
Add_Goto (Table.States (17), 309, 107);
- Add_Goto (Table.States (17), 311, 108);
- Add_Goto (Table.States (17), 313, 109);
- Add_Goto (Table.States (17), 316, 111);
+ Add_Goto (Table.States (17), 310, 108);
+ Add_Goto (Table.States (17), 312, 109);
+ Add_Goto (Table.States (17), 314, 110);
Add_Goto (Table.States (17), 317, 112);
- Add_Goto (Table.States (17), 319, 113);
- Add_Goto (Table.States (17), 325, 115);
- Add_Goto (Table.States (17), 331, 116);
- Table.States (17).Kernel := To_Vector (((142, 49, 3, False), (332,
49, 3, False)));
- Table.States (17).Minimal_Complete_Actions := To_Vector (((Reduce,
246, 0), (Shift, 74, 184)));
- Table.States (18).Action_List.Set_Capacity (3);
- Add_Action (Table.States (18), 104, 119);
- Add_Action (Table.States (18), 105, 33);
+ Add_Goto (Table.States (17), 318, 113);
+ Add_Goto (Table.States (17), 320, 114);
+ Add_Goto (Table.States (17), 326, 116);
+ Add_Goto (Table.States (17), 332, 117);
+ Table.States (17).Kernel := To_Vector (((143, 49, 3, False), (333,
49, 3, False)));
+ Table.States (17).Minimal_Complete_Actions := To_Vector (((Reduce,
247, 0), (Shift, 74, 185)));
+ Table.States (18).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (18), 79, 31);
+ Add_Action (Table.States (18), 105, 120);
Add_Action (Table.States (18), 106, 34);
+ Add_Action (Table.States (18), 107, 35);
Table.States (18).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (18), 128, 41);
- Add_Goto (Table.States (18), 239, 187);
- Add_Goto (Table.States (18), 272, 92);
- Add_Goto (Table.States (18), 293, 97);
- Table.States (18).Kernel := To_Vector ((0 => (262, 50, 1, False)));
- Table.States (18).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
+ Add_Goto (Table.States (18), 129, 42);
+ Add_Goto (Table.States (18), 240, 188);
+ Add_Goto (Table.States (18), 273, 93);
+ Add_Goto (Table.States (18), 294, 98);
+ Table.States (18).Kernel := To_Vector ((0 => (263, 50, 1, False)));
+ Table.States (18).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
Table.States (19).Action_List.Set_Capacity (3);
- Add_Action (Table.States (19), 14, 188);
- Add_Action (Table.States (19), 69, 189);
- Add_Action (Table.States (19), 104, 190);
- Table.States (19).Kernel := To_Vector (((264, 51, 5, False), (265,
51, 5, False), (271, 51, 8, False),
- (271, 51, 5, False), (304, 51, 7, False), (304, 51, 4, False)));
- Table.States (19).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 190)));
- Table.States (20).Action_List.Set_Capacity (4);
- Add_Action (Table.States (20), 96, 191);
- Add_Action (Table.States (20), 104, 119);
- Add_Action (Table.States (20), 105, 33);
+ Add_Action (Table.States (19), 14, 189);
+ Add_Action (Table.States (19), 69, 190);
+ Add_Action (Table.States (19), 105, 191);
+ Table.States (19).Kernel := To_Vector (((265, 51, 5, False), (266,
51, 5, False), (272, 51, 8, False),
+ (272, 51, 5, False), (305, 51, 7, False), (305, 51, 4, False)));
+ Table.States (19).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 191)));
+ Table.States (20).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (20), 79, 31);
+ Add_Action (Table.States (20), 97, 192);
+ Add_Action (Table.States (20), 105, 120);
Add_Action (Table.States (20), 106, 34);
+ Add_Action (Table.States (20), 107, 35);
Table.States (20).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (20), 128, 41);
- Add_Goto (Table.States (20), 239, 192);
- Add_Goto (Table.States (20), 272, 92);
- Add_Goto (Table.States (20), 293, 97);
- Table.States (20).Kernel := To_Vector (((276, 52, 3, False), (276,
52, 2, False), (276, 52, 1, False)));
- Table.States (20).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 191)));
- Table.States (21).Action_List.Set_Capacity (3);
- Add_Action (Table.States (21), 104, 119);
- Add_Action (Table.States (21), 105, 33);
+ Add_Goto (Table.States (20), 129, 42);
+ Add_Goto (Table.States (20), 240, 193);
+ Add_Goto (Table.States (20), 273, 93);
+ Add_Goto (Table.States (20), 294, 98);
+ Table.States (20).Kernel := To_Vector (((277, 52, 3, False), (277,
52, 2, False), (277, 52, 1, False)));
+ Table.States (20).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 192)));
+ Table.States (21).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (21), 79, 31);
+ Add_Action (Table.States (21), 105, 120);
Add_Action (Table.States (21), 106, 34);
+ Add_Action (Table.States (21), 107, 35);
Table.States (21).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (21), 128, 41);
- Add_Goto (Table.States (21), 239, 193);
- Add_Goto (Table.States (21), 272, 92);
- Add_Goto (Table.States (21), 293, 97);
- Table.States (21).Kernel := To_Vector (((290, 57, 4, False), (290,
57, 2, False)));
- Table.States (21).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (22).Action_List.Set_Capacity (14);
- Add_Action (Table.States (22), 3, 121);
- Add_Action (Table.States (22), 21, Reduce, (195, 1), 0, null,
null);
- Add_Action (Table.States (22), 39, 122);
- Add_Action (Table.States (22), 40, 123);
- Add_Action (Table.States (22), 41, 124);
- Add_Action (Table.States (22), 52, 125);
- Add_Action (Table.States (22), 76, 126);
- Add_Action (Table.States (22), 94, 127);
+ Add_Goto (Table.States (21), 129, 42);
+ Add_Goto (Table.States (21), 240, 194);
+ Add_Goto (Table.States (21), 273, 93);
+ Add_Goto (Table.States (21), 294, 98);
+ Table.States (21).Kernel := To_Vector (((291, 57, 4, False), (291,
57, 2, False)));
+ Table.States (21).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (22).Action_List.Set_Capacity (15);
+ Add_Action (Table.States (22), 3, 122);
+ Add_Action (Table.States (22), 21, Reduce, (196, 1), 0, null,
null);
+ Add_Action (Table.States (22), 39, 123);
+ Add_Action (Table.States (22), 40, 124);
+ Add_Action (Table.States (22), 41, 125);
+ Add_Action (Table.States (22), 52, 126);
+ Add_Action (Table.States (22), 76, 127);
+ Add_Action (Table.States (22), 79, 31);
Add_Action (Table.States (22), 95, 128);
- Add_Action (Table.States (22), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (22), 103, 129);
- Add_Action (Table.States (22), 104, 194);
- Add_Action (Table.States (22), 105, 33);
+ Add_Action (Table.States (22), 96, 129);
+ Add_Action (Table.States (22), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (22), 104, 130);
+ Add_Action (Table.States (22), 105, 195);
Add_Action (Table.States (22), 106, 34);
+ Add_Action (Table.States (22), 107, 35);
Table.States (22).Goto_List.Set_Capacity (22);
- Add_Goto (Table.States (22), 117, 130);
- Add_Goto (Table.States (22), 128, 41);
- Add_Goto (Table.States (22), 191, 131);
- Add_Goto (Table.States (22), 192, 195);
- Add_Goto (Table.States (22), 194, 196);
+ Add_Goto (Table.States (22), 118, 131);
+ Add_Goto (Table.States (22), 129, 42);
+ Add_Goto (Table.States (22), 192, 132);
+ Add_Goto (Table.States (22), 193, 196);
Add_Goto (Table.States (22), 195, 197);
- Add_Goto (Table.States (22), 197, 133);
- Add_Goto (Table.States (22), 239, 134);
- Add_Goto (Table.States (22), 258, 135);
- Add_Goto (Table.States (22), 272, 92);
- Add_Goto (Table.States (22), 275, 136);
- Add_Goto (Table.States (22), 282, 137);
+ Add_Goto (Table.States (22), 196, 198);
+ Add_Goto (Table.States (22), 198, 134);
+ Add_Goto (Table.States (22), 240, 135);
+ Add_Goto (Table.States (22), 259, 136);
+ Add_Goto (Table.States (22), 273, 93);
+ Add_Goto (Table.States (22), 276, 137);
Add_Goto (Table.States (22), 283, 138);
Add_Goto (Table.States (22), 284, 139);
Add_Goto (Table.States (22), 285, 140);
Add_Goto (Table.States (22), 286, 141);
Add_Goto (Table.States (22), 287, 142);
- Add_Goto (Table.States (22), 293, 97);
- Add_Goto (Table.States (22), 301, 143);
- Add_Goto (Table.States (22), 320, 144);
+ Add_Goto (Table.States (22), 288, 143);
+ Add_Goto (Table.States (22), 294, 98);
+ Add_Goto (Table.States (22), 302, 144);
Add_Goto (Table.States (22), 321, 145);
- Add_Goto (Table.States (22), 330, 146);
- Table.States (22).Kernel := To_Vector (((196, 58, 4, False), (196,
58, 4, False), (302, 58, 1, False)));
- Table.States (22).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
+ Add_Goto (Table.States (22), 322, 146);
+ Add_Goto (Table.States (22), 331, 147);
+ Table.States (22).Kernel := To_Vector (((197, 58, 4, False), (197,
58, 4, False), (303, 58, 1, False)));
+ Table.States (22).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
Table.States (23).Action_List.Set_Capacity (1);
- Add_Action (Table.States (23), 76, 198);
- Table.States (23).Kernel := To_Vector ((0 => (315, 60, 9, False)));
- Table.States (23).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 76, 198)));
- Table.States (24).Action_List.Set_Capacity (9);
+ Add_Action (Table.States (23), 76, 199);
+ Table.States (23).Kernel := To_Vector ((0 => (316, 60, 9, False)));
+ Table.States (23).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 76, 199)));
+ Table.States (24).Action_List.Set_Capacity (10);
Add_Action (Table.States (24), 4, 1);
Add_Action (Table.States (24), 18, 4);
- Add_Action (Table.States (24), 22, Reduce, (297, 1), 0, null,
null);
- Add_Action (Table.States (24), 24, Reduce, (297, 1), 0, null,
null);
- Add_Action (Table.States (24), 67, 199);
- Add_Action (Table.States (24), 72, 200);
- Add_Action (Table.States (24), 104, 119);
- Add_Action (Table.States (24), 105, 33);
+ Add_Action (Table.States (24), 22, Reduce, (298, 1), 0, null,
null);
+ Add_Action (Table.States (24), 24, Reduce, (298, 1), 0, null,
null);
+ Add_Action (Table.States (24), 67, 200);
+ Add_Action (Table.States (24), 72, 201);
+ Add_Action (Table.States (24), 79, 31);
+ Add_Action (Table.States (24), 105, 120);
Add_Action (Table.States (24), 106, 34);
+ Add_Action (Table.States (24), 107, 35);
Table.States (24).Goto_List.Set_Capacity (13);
- Add_Goto (Table.States (24), 113, 201);
- Add_Goto (Table.States (24), 128, 41);
- Add_Goto (Table.States (24), 160, 202);
+ Add_Goto (Table.States (24), 114, 202);
+ Add_Goto (Table.States (24), 129, 42);
Add_Goto (Table.States (24), 161, 203);
- Add_Goto (Table.States (24), 178, 204);
- Add_Goto (Table.States (24), 239, 205);
- Add_Goto (Table.States (24), 261, 206);
- Add_Goto (Table.States (24), 272, 92);
- Add_Goto (Table.States (24), 293, 97);
- Add_Goto (Table.States (24), 295, 207);
+ Add_Goto (Table.States (24), 162, 204);
+ Add_Goto (Table.States (24), 179, 205);
+ Add_Goto (Table.States (24), 240, 206);
+ Add_Goto (Table.States (24), 262, 207);
+ Add_Goto (Table.States (24), 273, 93);
+ Add_Goto (Table.States (24), 294, 98);
Add_Goto (Table.States (24), 296, 208);
Add_Goto (Table.States (24), 297, 209);
- Add_Goto (Table.States (24), 324, 210);
- Table.States (24).Kernel := To_Vector (((126, 61, 6, False), (152,
61, 5, False), (294, 61, 4, False),
- (294, 61, 3, False), (323, 61, 7, False)));
- Table.States (24).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 297, 0)));
+ Add_Goto (Table.States (24), 298, 210);
+ Add_Goto (Table.States (24), 325, 211);
+ Table.States (24).Kernel := To_Vector (((127, 61, 6, False), (153,
61, 5, False), (295, 61, 4, False),
+ (295, 61, 3, False), (324, 61, 7, False)));
+ Table.States (24).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 298, 0)));
Table.States (25).Action_List.Set_Capacity (1);
- Add_Action (Table.States (25), 104, 211);
- Table.States (25).Kernel := To_Vector ((0 => (313, 63, 4, False)));
- Table.States (25).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 211)));
+ Add_Action (Table.States (25), 105, 212);
+ Table.States (25).Kernel := To_Vector ((0 => (314, 63, 4, False)));
+ Table.States (25).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 212)));
Table.States (26).Action_List.Set_Capacity (3);
- Add_Action (Table.States (26), 14, 212);
- Add_Action (Table.States (26), 69, 213);
- Add_Action (Table.States (26), 104, 214);
- Table.States (26).Kernel := To_Vector (((305, 66, 7, False), (305,
66, 4, False), (305, 66, 2, False),
- (316, 66, 6, False), (317, 66, 5, False), (319, 66, 8, False),
(319, 66, 5, False), (319, 66, 3, False)));
- Table.States (26).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 214)));
+ Add_Action (Table.States (26), 14, 213);
+ Add_Action (Table.States (26), 69, 214);
+ Add_Action (Table.States (26), 105, 215);
+ Table.States (26).Kernel := To_Vector (((306, 66, 7, False), (306,
66, 4, False), (306, 66, 2, False),
+ (317, 66, 6, False), (318, 66, 5, False), (320, 66, 8, False),
(320, 66, 5, False), (320, 66, 3, False)));
+ Table.States (26).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 215)));
Table.States (27).Action_List.Set_Capacity (1);
- Add_Action (Table.States (27), 104, 215);
- Table.States (27).Kernel := To_Vector (((206, 69, 4, False), (223,
69, 4, False), (223, 69, 2, False),
- (259, 69, 7, False), (260, 69, 4, False)));
- Table.States (27).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 215)));
- Table.States (28).Action_List.Set_Capacity (5);
- Add_Action (Table.States (28), 9, 216);
- Add_Action (Table.States (28), 69, 217);
- Add_Action (Table.States (28), 104, 119);
- Add_Action (Table.States (28), 105, 33);
+ Add_Action (Table.States (27), 105, 216);
+ Table.States (27).Kernel := To_Vector (((207, 69, 4, False), (224,
69, 4, False), (224, 69, 2, False),
+ (260, 69, 7, False), (261, 69, 4, False)));
+ Table.States (27).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 216)));
+ Table.States (28).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (28), 9, 217);
+ Add_Action (Table.States (28), 69, 218);
+ Add_Action (Table.States (28), 79, 31);
+ Add_Action (Table.States (28), 105, 120);
Add_Action (Table.States (28), 106, 34);
+ Add_Action (Table.States (28), 107, 35);
Table.States (28).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (28), 128, 41);
- Add_Goto (Table.States (28), 238, 218);
+ Add_Goto (Table.States (28), 129, 42);
Add_Goto (Table.States (28), 239, 219);
- Add_Goto (Table.States (28), 272, 92);
- Add_Goto (Table.States (28), 293, 97);
- Table.States (28).Kernel := To_Vector (((331, 71, 4, False), (331,
71, 3, False), (331, 71, 2, False)));
- Table.States (28).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (29).Action_List.Set_Capacity (13);
- Add_Action (Table.States (29), 3, 121);
- Add_Action (Table.States (29), 37, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (29), 39, 122);
- Add_Action (Table.States (29), 40, 123);
- Add_Action (Table.States (29), 41, 124);
- Add_Action (Table.States (29), 52, 125);
- Add_Action (Table.States (29), 76, 126);
- Add_Action (Table.States (29), 94, 127);
+ Add_Goto (Table.States (28), 240, 220);
+ Add_Goto (Table.States (28), 273, 93);
+ Add_Goto (Table.States (28), 294, 98);
+ Table.States (28).Kernel := To_Vector (((332, 71, 4, False), (332,
71, 3, False), (332, 71, 2, False)));
+ Table.States (28).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (29).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (29), 3, 122);
+ Add_Action (Table.States (29), 37, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (29), 39, 123);
+ Add_Action (Table.States (29), 40, 124);
+ Add_Action (Table.States (29), 41, 125);
+ Add_Action (Table.States (29), 52, 126);
+ Add_Action (Table.States (29), 76, 127);
+ Add_Action (Table.States (29), 79, 31);
Add_Action (Table.States (29), 95, 128);
- Add_Action (Table.States (29), 103, 129);
- Add_Action (Table.States (29), 104, 119);
- Add_Action (Table.States (29), 105, 33);
+ Add_Action (Table.States (29), 96, 129);
+ Add_Action (Table.States (29), 104, 130);
+ Add_Action (Table.States (29), 105, 120);
Add_Action (Table.States (29), 106, 34);
+ Add_Action (Table.States (29), 107, 35);
Table.States (29).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (29), 117, 130);
- Add_Goto (Table.States (29), 128, 41);
- Add_Goto (Table.States (29), 191, 131);
- Add_Goto (Table.States (29), 192, 220);
- Add_Goto (Table.States (29), 197, 133);
- Add_Goto (Table.States (29), 239, 134);
- Add_Goto (Table.States (29), 258, 135);
- Add_Goto (Table.States (29), 272, 92);
- Add_Goto (Table.States (29), 275, 136);
- Add_Goto (Table.States (29), 282, 137);
+ Add_Goto (Table.States (29), 118, 131);
+ Add_Goto (Table.States (29), 129, 42);
+ Add_Goto (Table.States (29), 192, 132);
+ Add_Goto (Table.States (29), 193, 221);
+ Add_Goto (Table.States (29), 198, 134);
+ Add_Goto (Table.States (29), 240, 135);
+ Add_Goto (Table.States (29), 259, 136);
+ Add_Goto (Table.States (29), 273, 93);
+ Add_Goto (Table.States (29), 276, 137);
Add_Goto (Table.States (29), 283, 138);
Add_Goto (Table.States (29), 284, 139);
Add_Goto (Table.States (29), 285, 140);
Add_Goto (Table.States (29), 286, 141);
Add_Goto (Table.States (29), 287, 142);
- Add_Goto (Table.States (29), 293, 97);
- Add_Goto (Table.States (29), 301, 143);
- Add_Goto (Table.States (29), 320, 144);
+ Add_Goto (Table.States (29), 288, 143);
+ Add_Goto (Table.States (29), 294, 98);
+ Add_Goto (Table.States (29), 302, 144);
Add_Goto (Table.States (29), 321, 145);
- Add_Goto (Table.States (29), 330, 146);
- Table.States (29).Kernel := To_Vector ((0 => (229, 73, 0, False)));
- Table.States (29).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (30).Action_List.Set_Capacity (3);
- Add_Action (Table.States (30), 104, 119);
- Add_Action (Table.States (30), 105, 33);
+ Add_Goto (Table.States (29), 322, 146);
+ Add_Goto (Table.States (29), 331, 147);
+ Table.States (29).Kernel := To_Vector ((0 => (230, 73, 0, False)));
+ Table.States (29).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (30).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (30), 79, 31);
+ Add_Action (Table.States (30), 105, 120);
Add_Action (Table.States (30), 106, 34);
+ Add_Action (Table.States (30), 107, 35);
Table.States (30).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (30), 128, 41);
- Add_Goto (Table.States (30), 238, 221);
- Add_Goto (Table.States (30), 239, 219);
- Add_Goto (Table.States (30), 272, 92);
- Add_Goto (Table.States (30), 293, 97);
- Table.States (30).Kernel := To_Vector ((0 => (332, 74, 2, False)));
- Table.States (30).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (31).Action_List.Set_Capacity (1);
- Add_Action (Table.States (31), 104, 222);
- Table.States (31).Kernel := To_Vector ((0 => (217, 93, 2, False)));
- Table.States (31).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 222)));
- Table.States (32).Action_List.Set_Capacity (8);
- Add_Action (Table.States (32), 76, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (32), 81, 223);
- Add_Conflict (Table.States (32), 81, (219, 1), 1,
identifier_list_1'Access, null);
- Add_Action (Table.States (32), 82, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (32), 83, Reduce, (219, 1), 1,
identifier_list_1'Access, null);
- Add_Action (Table.States (32), 84, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (32), 96, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (32), 101, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (32), 102, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Table.States (32).Kernel := To_Vector (((131, 104, 1, False),
(219, 104, 0, False), (239, 104, 0, False),
- (245, 104, 5, False), (245, 104, 6, False), (245, 104, 5, False)));
- Table.States (32).Minimal_Complete_Actions := To_Vector (((Reduce,
219, 1), (Reduce, 239, 1)));
- Table.States (33).Action_List.Set_Capacity (62);
- Add_Action (Table.States (33), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
- 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 73, 74, 75,
76, 77, 78, 79, 82, 83, 84, 85, 86, 87, 88,
- 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105,
106), (239, 7), 1, null,
- name_7_check'Access);
- Table.States (33).Kernel := To_Vector ((0 => (239, 105, 0,
False)));
- Table.States (33).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 239, 1)));
+ Add_Goto (Table.States (30), 129, 42);
+ Add_Goto (Table.States (30), 239, 222);
+ Add_Goto (Table.States (30), 240, 220);
+ Add_Goto (Table.States (30), 273, 93);
+ Add_Goto (Table.States (30), 294, 98);
+ Table.States (30).Kernel := To_Vector ((0 => (333, 74, 2, False)));
+ Table.States (30).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (31).Action_List.Set_Capacity (64);
+ Add_Action (Table.States (31), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+ 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
105, 106, 107), (240, 8), 1, null, null);
+ Table.States (31).Kernel := To_Vector ((0 => (240, 79, 0, False)));
+ Table.States (31).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 240, 1)));
+ Table.States (32).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (32), 105, 223);
+ Table.States (32).Kernel := To_Vector ((0 => (218, 94, 2, False)));
+ Table.States (32).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 223)));
+ Table.States (33).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (33), 76, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (33), 82, 224);
+ Add_Conflict (Table.States (33), 82, (220, 1), 1,
identifier_list_1'Access, null);
+ Add_Action (Table.States (33), 83, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (33), 84, Reduce, (220, 1), 1,
identifier_list_1'Access, null);
+ Add_Action (Table.States (33), 85, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (33), 97, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (33), 102, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (33), 103, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Table.States (33).Kernel := To_Vector (((132, 105, 1, False),
(220, 105, 0, False), (240, 105, 0, False),
+ (246, 105, 5, False), (246, 105, 6, False), (246, 105, 5, False)));
+ Table.States (33).Minimal_Complete_Actions := To_Vector (((Reduce,
220, 1), (Reduce, 240, 1)));
Table.States (34).Action_List.Set_Capacity (63);
Add_Action (Table.States (34), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
- 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
- 88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104,
105, 106), (239, 6), 1, null, null);
- Table.States (34).Kernel := To_Vector ((0 => (239, 106, 0,
False)));
- Table.States (34).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 239, 1)));
- Table.States (35).Action_List.Set_Capacity (40);
- Add_Action (Table.States (35), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (157, 0), 1, null,
- null);
- Table.States (35).Kernel := To_Vector ((0 => (157, 112, 0,
False)));
- Table.States (35).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 157, 1)));
- Table.States (36).Action_List.Set_Capacity (46);
- Add_Action (Table.States (36), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (151, 5), 1, null, null);
- Table.States (36).Kernel := To_Vector ((0 => (151, 113, 0,
False)));
- Table.States (36).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 151, 1)));
- Table.States (37).Action_List.Set_Capacity (40);
- Add_Action (Table.States (37), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (157, 1), 1, null,
- null);
- Table.States (37).Kernel := To_Vector ((0 => (157, 121, 0,
False)));
- Table.States (37).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 157, 1)));
- Table.States (38).Action_List.Set_Capacity (46);
- Add_Action (Table.States (38), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (303, 1), 1, null, null);
- Table.States (38).Kernel := To_Vector ((0 => (303, 123, 0,
False)));
- Table.States (38).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 303, 1)));
- Table.States (39).Action_List.Set_Capacity (46);
- Add_Action (Table.States (39), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (298, 3), 1, null, null);
- Table.States (39).Kernel := To_Vector ((0 => (298, 126, 0,
False)));
- Table.States (39).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 298, 1)));
- Table.States (40).Action_List.Set_Capacity (41);
- Add_Action (Table.States (40), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73,
74, 93, 104, 105, 106, 107), (121, 3), 1,
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 73, 74, 75,
76, 77, 78, 79, 80, 83, 84, 85, 86, 87, 88,
+ 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 105,
106, 107), (240, 7), 1, null,
+ name_7_check'Access);
+ Table.States (34).Kernel := To_Vector ((0 => (240, 106, 0,
False)));
+ Table.States (34).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 240, 1)));
+ Table.States (35).Action_List.Set_Capacity (64);
+ Add_Action (Table.States (35), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+ 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
105, 106, 107), (240, 6), 1, null, null);
+ Table.States (35).Kernel := To_Vector ((0 => (240, 107, 0,
False)));
+ Table.States (35).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 240, 1)));
+ Table.States (36).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (36), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (158, 0), 1,
null, null);
- Table.States (40).Kernel := To_Vector ((0 => (121, 127, 0,
False)));
- Table.States (40).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 121, 1)));
- Table.States (41).Action_List.Set_Capacity (62);
- Add_Action (Table.States (41), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
- 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 73, 74, 75,
76, 77, 78, 79, 82, 83, 84, 85, 86, 87, 88,
- 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105,
106), (239, 3), 1, null, null);
- Table.States (41).Kernel := To_Vector ((0 => (239, 128, 0, True)));
- Table.States (41).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 239, 1)));
- Table.States (41).Minimal_Complete_Actions_Recursive := True;
- Table.States (42).Action_List.Set_Capacity (5);
- Add_Action (Table.States (42), (13, 17, 28, 37, 73), (132, 0), 1,
null, block_label_opt_0_check'Access);
- Table.States (42).Kernel := To_Vector ((0 => (132, 131, 0,
False)));
- Table.States (42).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 132, 1)));
+ Table.States (36).Kernel := To_Vector ((0 => (158, 113, 0,
False)));
+ Table.States (36).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 158, 1)));
+ Table.States (37).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (37), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (152, 5), 1, null, null);
+ Table.States (37).Kernel := To_Vector ((0 => (152, 114, 0,
False)));
+ Table.States (37).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 152, 1)));
+ Table.States (38).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (38), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (158, 1), 1,
+ null, null);
+ Table.States (38).Kernel := To_Vector ((0 => (158, 122, 0,
False)));
+ Table.States (38).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 158, 1)));
+ Table.States (39).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (39), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (304, 1), 1, null, null);
+ Table.States (39).Kernel := To_Vector ((0 => (304, 124, 0,
False)));
+ Table.States (39).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 304, 1)));
+ Table.States (40).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (40), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (299, 3), 1, null, null);
+ Table.States (40).Kernel := To_Vector ((0 => (299, 127, 0,
False)));
+ Table.States (40).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 299, 1)));
+ Table.States (41).Action_List.Set_Capacity (42);
+ Add_Action (Table.States (41), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73,
74, 79, 94, 105, 106, 107, 108), (122, 3),
+ 1, null, null);
+ Table.States (41).Kernel := To_Vector ((0 => (122, 128, 0,
False)));
+ Table.States (41).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 1)));
+ Table.States (42).Action_List.Set_Capacity (63);
+ Add_Action (Table.States (42), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 73, 74, 75,
76, 77, 78, 79, 80, 83, 84, 85, 86, 87, 88,
+ 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 105,
106, 107), (240, 3), 1, null, null);
+ Table.States (42).Kernel := To_Vector ((0 => (240, 129, 0, True)));
+ Table.States (42).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 240, 1)));
+ Table.States (42).Minimal_Complete_Actions_Recursive := True;
Table.States (43).Action_List.Set_Capacity (5);
- Add_Action (Table.States (43), 13, 224);
- Add_Action (Table.States (43), 17, 225);
- Add_Action (Table.States (43), 28, 226);
- Add_Action (Table.States (43), 37, 227);
- Add_Action (Table.States (43), 73, 29);
- Table.States (43).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (43), 229, 228);
- Table.States (43).Kernel := To_Vector (((133, 132, 4, False),
(133, 132, 3, False), (232, 132, 5, False),
- (232, 132, 4, False)));
- Table.States (43).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 13, 224)));
- Table.States (44).Action_List.Set_Capacity (46);
- Add_Action (Table.States (44), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (151, 3), 1, null, null);
- Table.States (44).Kernel := To_Vector ((0 => (151, 133, 0,
False)));
- Table.States (44).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 151, 1)));
- Table.States (45).Action_List.Set_Capacity (40);
- Add_Action (Table.States (45), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (157, 2), 1, null,
- null);
- Table.States (45).Kernel := To_Vector ((0 => (157, 134, 0,
False)));
- Table.States (45).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 157, 1)));
- Table.States (46).Action_List.Set_Capacity (40);
+ Add_Action (Table.States (43), (13, 17, 28, 37, 73), (133, 0), 1,
null, block_label_opt_0_check'Access);
+ Table.States (43).Kernel := To_Vector ((0 => (133, 132, 0,
False)));
+ Table.States (43).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 133, 1)));
+ Table.States (44).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (44), 13, 225);
+ Add_Action (Table.States (44), 17, 226);
+ Add_Action (Table.States (44), 28, 227);
+ Add_Action (Table.States (44), 37, 228);
+ Add_Action (Table.States (44), 73, 29);
+ Table.States (44).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (44), 230, 229);
+ Table.States (44).Kernel := To_Vector (((134, 133, 4, False),
(134, 133, 3, False), (233, 133, 5, False),
+ (233, 133, 4, False)));
+ Table.States (44).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 13, 225)));
+ Table.States (45).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (45), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (152, 3), 1, null, null);
+ Table.States (45).Kernel := To_Vector ((0 => (152, 134, 0,
False)));
+ Table.States (45).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 152, 1)));
+ Table.States (46).Action_List.Set_Capacity (41);
Add_Action (Table.States (46), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (134, 1), 1, null,
- null);
- Table.States (46).Kernel := To_Vector ((0 => (134, 135, 0,
False)));
- Table.States (46).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 134, 1)));
- Table.States (47).Action_List.Set_Capacity (46);
- Add_Action (Table.States (47), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (151, 1), 1, null, null);
- Table.States (47).Kernel := To_Vector ((0 => (151, 139, 0,
False)));
- Table.States (47).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 151, 1)));
- Table.States (48).Action_List.Set_Capacity (39);
- Add_Action (Table.States (48), (4, 5, 13, 15, 17, 18, 25, 27, 28,
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
- 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93,
104, 105, 106, 107), (143, 1), 1,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (158, 2), 1,
+ null, null);
+ Table.States (46).Kernel := To_Vector ((0 => (158, 135, 0,
False)));
+ Table.States (46).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 158, 1)));
+ Table.States (47).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (47), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (135, 1), 1,
+ null, null);
+ Table.States (47).Kernel := To_Vector ((0 => (135, 136, 0,
False)));
+ Table.States (47).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 135, 1)));
+ Table.States (48).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (48), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (152, 1), 1, null, null);
+ Table.States (48).Kernel := To_Vector ((0 => (152, 140, 0,
False)));
+ Table.States (48).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 152, 1)));
+ Table.States (49).Action_List.Set_Capacity (40);
+ Add_Action (Table.States (49), (4, 5, 13, 15, 17, 18, 25, 27, 28,
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
+ 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 79,
94, 105, 106, 107, 108), (144, 1), 1,
compilation_unit_list_1'Access,
compilation_unit_list_1_check'Access);
- Table.States (48).Kernel := To_Vector ((0 => (143, 142, 0,
False)));
- Table.States (48).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 143, 1)));
- Table.States (49).Action_List.Set_Capacity (39);
- Add_Action (Table.States (49), 4, 1);
- Add_Action (Table.States (49), 5, 2);
- Add_Action (Table.States (49), 13, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (49), 15, 3);
- Add_Action (Table.States (49), 17, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (49), 18, 4);
- Add_Action (Table.States (49), 25, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (49), 27, 5);
- Add_Action (Table.States (49), 28, 6);
- Add_Conflict (Table.States (49), 28, (132, 1), 0, null, null);
- Add_Action (Table.States (49), 29, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (49), 30, 8);
- Add_Action (Table.States (49), 31, 9);
- Add_Action (Table.States (49), 32, 10);
- Add_Action (Table.States (49), 36, 11);
- Add_Action (Table.States (49), 37, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (49), 40, 12);
- Add_Action (Table.States (49), 41, 13);
- Add_Action (Table.States (49), 46, 14);
- Add_Action (Table.States (49), 47, 15);
- Add_Action (Table.States (49), 48, 16);
- Add_Action (Table.States (49), 49, 17);
- Add_Action (Table.States (49), 50, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (49), 51, 19);
- Add_Action (Table.States (49), 52, 20);
- Add_Action (Table.States (49), 57, 21);
- Add_Action (Table.States (49), 58, 22);
- Add_Action (Table.States (49), 60, 23);
- Add_Action (Table.States (49), 61, 24);
- Add_Action (Table.States (49), 63, 25);
- Add_Action (Table.States (49), 66, 26);
- Add_Action (Table.States (49), 69, 27);
- Add_Action (Table.States (49), 71, 28);
- Add_Action (Table.States (49), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (49), 74, 30);
- Add_Action (Table.States (49), 93, 31);
- Add_Action (Table.States (49), 104, 32);
- Add_Action (Table.States (49), 105, 33);
- Add_Action (Table.States (49), 106, 34);
- Add_Action (Table.States (49), 107, Accept_It, (108, 0), 1, null,
null);
- Table.States (49).Goto_List.Set_Capacity (82);
- Add_Goto (Table.States (49), 112, 35);
- Add_Goto (Table.States (49), 113, 36);
- Add_Goto (Table.States (49), 121, 37);
- Add_Goto (Table.States (49), 123, 38);
- Add_Goto (Table.States (49), 126, 39);
- Add_Goto (Table.States (49), 127, 40);
- Add_Goto (Table.States (49), 128, 41);
- Add_Goto (Table.States (49), 131, 42);
- Add_Goto (Table.States (49), 132, 43);
- Add_Goto (Table.States (49), 133, 44);
- Add_Goto (Table.States (49), 134, 45);
- Add_Goto (Table.States (49), 135, 46);
- Add_Goto (Table.States (49), 139, 47);
- Add_Goto (Table.States (49), 142, 229);
- Add_Goto (Table.States (49), 151, 50);
- Add_Goto (Table.States (49), 152, 51);
- Add_Goto (Table.States (49), 157, 52);
- Add_Goto (Table.States (49), 161, 53);
- Add_Goto (Table.States (49), 179, 54);
- Add_Goto (Table.States (49), 182, 55);
- Add_Goto (Table.States (49), 186, 56);
- Add_Goto (Table.States (49), 190, 57);
- Add_Goto (Table.States (49), 193, 58);
- Add_Goto (Table.States (49), 196, 59);
- Add_Goto (Table.States (49), 206, 60);
- Add_Goto (Table.States (49), 207, 61);
- Add_Goto (Table.States (49), 209, 62);
- Add_Goto (Table.States (49), 210, 63);
- Add_Goto (Table.States (49), 213, 64);
- Add_Goto (Table.States (49), 214, 65);
- Add_Goto (Table.States (49), 215, 66);
- Add_Goto (Table.States (49), 216, 67);
- Add_Goto (Table.States (49), 217, 68);
- Add_Goto (Table.States (49), 219, 69);
- Add_Goto (Table.States (49), 222, 70);
- Add_Goto (Table.States (49), 223, 71);
- Add_Goto (Table.States (49), 232, 72);
- Add_Goto (Table.States (49), 239, 73);
- Add_Goto (Table.States (49), 243, 74);
- Add_Goto (Table.States (49), 244, 75);
- Add_Goto (Table.States (49), 245, 76);
- Add_Goto (Table.States (49), 246, 77);
- Add_Goto (Table.States (49), 247, 78);
- Add_Goto (Table.States (49), 248, 79);
- Add_Goto (Table.States (49), 249, 80);
- Add_Goto (Table.States (49), 250, 81);
- Add_Goto (Table.States (49), 251, 82);
- Add_Goto (Table.States (49), 257, 83);
- Add_Goto (Table.States (49), 259, 84);
- Add_Goto (Table.States (49), 260, 85);
- Add_Goto (Table.States (49), 261, 86);
- Add_Goto (Table.States (49), 262, 87);
- Add_Goto (Table.States (49), 263, 88);
- Add_Goto (Table.States (49), 264, 89);
- Add_Goto (Table.States (49), 265, 90);
- Add_Goto (Table.States (49), 271, 91);
- Add_Goto (Table.States (49), 272, 92);
- Add_Goto (Table.States (49), 276, 93);
- Add_Goto (Table.States (49), 281, 94);
- Add_Goto (Table.States (49), 289, 95);
- Add_Goto (Table.States (49), 290, 96);
- Add_Goto (Table.States (49), 293, 97);
- Add_Goto (Table.States (49), 294, 98);
- Add_Goto (Table.States (49), 298, 99);
- Add_Goto (Table.States (49), 302, 100);
- Add_Goto (Table.States (49), 303, 101);
- Add_Goto (Table.States (49), 304, 102);
- Add_Goto (Table.States (49), 305, 103);
- Add_Goto (Table.States (49), 306, 104);
- Add_Goto (Table.States (49), 307, 105);
- Add_Goto (Table.States (49), 308, 106);
- Add_Goto (Table.States (49), 309, 107);
- Add_Goto (Table.States (49), 311, 108);
- Add_Goto (Table.States (49), 313, 109);
- Add_Goto (Table.States (49), 315, 110);
- Add_Goto (Table.States (49), 316, 111);
- Add_Goto (Table.States (49), 317, 112);
- Add_Goto (Table.States (49), 319, 113);
- Add_Goto (Table.States (49), 323, 114);
- Add_Goto (Table.States (49), 325, 115);
- Add_Goto (Table.States (49), 331, 116);
- Add_Goto (Table.States (49), 332, 117);
- Table.States (49).Kernel := To_Vector (((108, 143, 1, False),
(143, 143, 2, True)));
+ Table.States (49).Kernel := To_Vector ((0 => (144, 143, 0,
False)));
+ Table.States (49).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 144, 1)));
+ Table.States (50).Action_List.Set_Capacity (40);
+ Add_Action (Table.States (50), 4, 1);
+ Add_Action (Table.States (50), 5, 2);
+ Add_Action (Table.States (50), 13, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (50), 15, 3);
+ Add_Action (Table.States (50), 17, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (50), 18, 4);
+ Add_Action (Table.States (50), 25, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (50), 27, 5);
+ Add_Action (Table.States (50), 28, 6);
+ Add_Conflict (Table.States (50), 28, (133, 1), 0, null, null);
+ Add_Action (Table.States (50), 29, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (50), 30, 8);
+ Add_Action (Table.States (50), 31, 9);
+ Add_Action (Table.States (50), 32, 10);
+ Add_Action (Table.States (50), 36, 11);
+ Add_Action (Table.States (50), 37, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (50), 40, 12);
+ Add_Action (Table.States (50), 41, 13);
+ Add_Action (Table.States (50), 46, 14);
+ Add_Action (Table.States (50), 47, 15);
+ Add_Action (Table.States (50), 48, 16);
+ Add_Action (Table.States (50), 49, 17);
+ Add_Action (Table.States (50), 50, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (50), 51, 19);
+ Add_Action (Table.States (50), 52, 20);
+ Add_Action (Table.States (50), 57, 21);
+ Add_Action (Table.States (50), 58, 22);
+ Add_Action (Table.States (50), 60, 23);
+ Add_Action (Table.States (50), 61, 24);
+ Add_Action (Table.States (50), 63, 25);
+ Add_Action (Table.States (50), 66, 26);
+ Add_Action (Table.States (50), 69, 27);
+ Add_Action (Table.States (50), 71, 28);
+ Add_Action (Table.States (50), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (50), 74, 30);
+ Add_Action (Table.States (50), 79, 31);
+ Add_Action (Table.States (50), 94, 32);
+ Add_Action (Table.States (50), 105, 33);
+ Add_Action (Table.States (50), 106, 34);
+ Add_Action (Table.States (50), 107, 35);
+ Add_Action (Table.States (50), 108, Accept_It, (109, 0), 1, null,
null);
+ Table.States (50).Goto_List.Set_Capacity (82);
+ Add_Goto (Table.States (50), 113, 36);
+ Add_Goto (Table.States (50), 114, 37);
+ Add_Goto (Table.States (50), 122, 38);
+ Add_Goto (Table.States (50), 124, 39);
+ Add_Goto (Table.States (50), 127, 40);
+ Add_Goto (Table.States (50), 128, 41);
+ Add_Goto (Table.States (50), 129, 42);
+ Add_Goto (Table.States (50), 132, 43);
+ Add_Goto (Table.States (50), 133, 44);
+ Add_Goto (Table.States (50), 134, 45);
+ Add_Goto (Table.States (50), 135, 46);
+ Add_Goto (Table.States (50), 136, 47);
+ Add_Goto (Table.States (50), 140, 48);
+ Add_Goto (Table.States (50), 143, 230);
+ Add_Goto (Table.States (50), 152, 51);
+ Add_Goto (Table.States (50), 153, 52);
+ Add_Goto (Table.States (50), 158, 53);
+ Add_Goto (Table.States (50), 162, 54);
+ Add_Goto (Table.States (50), 180, 55);
+ Add_Goto (Table.States (50), 183, 56);
+ Add_Goto (Table.States (50), 187, 57);
+ Add_Goto (Table.States (50), 191, 58);
+ Add_Goto (Table.States (50), 194, 59);
+ Add_Goto (Table.States (50), 197, 60);
+ Add_Goto (Table.States (50), 207, 61);
+ Add_Goto (Table.States (50), 208, 62);
+ Add_Goto (Table.States (50), 210, 63);
+ Add_Goto (Table.States (50), 211, 64);
+ Add_Goto (Table.States (50), 214, 65);
+ Add_Goto (Table.States (50), 215, 66);
+ Add_Goto (Table.States (50), 216, 67);
+ Add_Goto (Table.States (50), 217, 68);
+ Add_Goto (Table.States (50), 218, 69);
+ Add_Goto (Table.States (50), 220, 70);
+ Add_Goto (Table.States (50), 223, 71);
+ Add_Goto (Table.States (50), 224, 72);
+ Add_Goto (Table.States (50), 233, 73);
+ Add_Goto (Table.States (50), 240, 74);
+ Add_Goto (Table.States (50), 244, 75);
+ Add_Goto (Table.States (50), 245, 76);
+ Add_Goto (Table.States (50), 246, 77);
+ Add_Goto (Table.States (50), 247, 78);
+ Add_Goto (Table.States (50), 248, 79);
+ Add_Goto (Table.States (50), 249, 80);
+ Add_Goto (Table.States (50), 250, 81);
+ Add_Goto (Table.States (50), 251, 82);
+ Add_Goto (Table.States (50), 252, 83);
+ Add_Goto (Table.States (50), 258, 84);
+ Add_Goto (Table.States (50), 260, 85);
+ Add_Goto (Table.States (50), 261, 86);
+ Add_Goto (Table.States (50), 262, 87);
+ Add_Goto (Table.States (50), 263, 88);
+ Add_Goto (Table.States (50), 264, 89);
+ Add_Goto (Table.States (50), 265, 90);
+ Add_Goto (Table.States (50), 266, 91);
+ Add_Goto (Table.States (50), 272, 92);
+ Add_Goto (Table.States (50), 273, 93);
+ Add_Goto (Table.States (50), 277, 94);
+ Add_Goto (Table.States (50), 282, 95);
+ Add_Goto (Table.States (50), 290, 96);
+ Add_Goto (Table.States (50), 291, 97);
+ Add_Goto (Table.States (50), 294, 98);
+ Add_Goto (Table.States (50), 295, 99);
+ Add_Goto (Table.States (50), 299, 100);
+ Add_Goto (Table.States (50), 303, 101);
+ Add_Goto (Table.States (50), 304, 102);
+ Add_Goto (Table.States (50), 305, 103);
+ Add_Goto (Table.States (50), 306, 104);
+ Add_Goto (Table.States (50), 307, 105);
+ Add_Goto (Table.States (50), 308, 106);
+ Add_Goto (Table.States (50), 309, 107);
+ Add_Goto (Table.States (50), 310, 108);
+ Add_Goto (Table.States (50), 312, 109);
+ Add_Goto (Table.States (50), 314, 110);
+ Add_Goto (Table.States (50), 316, 111);
+ Add_Goto (Table.States (50), 317, 112);
+ Add_Goto (Table.States (50), 318, 113);
+ Add_Goto (Table.States (50), 320, 114);
+ Add_Goto (Table.States (50), 324, 115);
+ Add_Goto (Table.States (50), 326, 116);
+ Add_Goto (Table.States (50), 332, 117);
+ Add_Goto (Table.States (50), 333, 118);
+ Table.States (50).Kernel := To_Vector (((109, 144, 1, False),
(144, 144, 2, True)));
end Subr_1;
procedure Subr_2
is begin
- Table.States (50).Action_List.Set_Capacity (46);
- Add_Action (Table.States (50), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (306, 2), 1, null, null);
- Table.States (50).Kernel := To_Vector ((0 => (306, 151, 0,
False)));
- Table.States (50).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 306, 1)));
- Table.States (51).Action_List.Set_Capacity (46);
+ Table.States (51).Action_List.Set_Capacity (47);
Add_Action (Table.States (51), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (298, 2), 1, null, null);
- Table.States (51).Kernel := To_Vector ((0 => (298, 152, 0,
False)));
- Table.States (51).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 298, 1)));
- Table.States (52).Action_List.Set_Capacity (39);
- Add_Action (Table.States (52), (4, 5, 13, 15, 17, 18, 25, 27, 28,
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
- 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93,
104, 105, 106, 107), (142, 3), 1, null,
- null);
- Table.States (52).Kernel := To_Vector ((0 => (142, 157, 0,
False)));
- Table.States (52).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 142, 1)));
- Table.States (53).Action_List.Set_Capacity (46);
- Add_Action (Table.States (53), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (303, 7), 1, null, null);
- Table.States (53).Kernel := To_Vector ((0 => (303, 161, 0,
False)));
- Table.States (53).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 303, 1)));
- Table.States (54).Action_List.Set_Capacity (40);
- Add_Action (Table.States (54), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (157, 3), 1, null,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (307, 2), 1, null, null);
+ Table.States (51).Kernel := To_Vector ((0 => (307, 152, 0,
False)));
+ Table.States (51).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 307, 1)));
+ Table.States (52).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (52), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (299, 2), 1, null, null);
+ Table.States (52).Kernel := To_Vector ((0 => (299, 153, 0,
False)));
+ Table.States (52).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 299, 1)));
+ Table.States (53).Action_List.Set_Capacity (40);
+ Add_Action (Table.States (53), (4, 5, 13, 15, 17, 18, 25, 27, 28,
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
+ 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 79,
94, 105, 106, 107, 108), (143, 3), 1, null,
null);
- Table.States (54).Kernel := To_Vector ((0 => (157, 179, 0,
False)));
- Table.States (54).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 157, 1)));
+ Table.States (53).Kernel := To_Vector ((0 => (143, 158, 0,
False)));
+ Table.States (53).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 143, 1)));
+ Table.States (54).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (54), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (304, 7), 1, null, null);
+ Table.States (54).Kernel := To_Vector ((0 => (304, 162, 0,
False)));
+ Table.States (54).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 304, 1)));
Table.States (55).Action_List.Set_Capacity (41);
Add_Action (Table.States (55), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73,
74, 93, 104, 105, 106, 107), (121, 1), 1,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (158, 3), 1,
null, null);
- Table.States (55).Kernel := To_Vector ((0 => (121, 182, 0,
False)));
- Table.States (55).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 121, 1)));
- Table.States (56).Action_List.Set_Capacity (40);
+ Table.States (55).Kernel := To_Vector ((0 => (158, 180, 0,
False)));
+ Table.States (55).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 158, 1)));
+ Table.States (56).Action_List.Set_Capacity (42);
Add_Action (Table.States (56), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (157, 4), 1, null,
- null);
- Table.States (56).Kernel := To_Vector ((0 => (157, 186, 0,
False)));
- Table.States (56).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 157, 1)));
- Table.States (57).Action_List.Set_Capacity (46);
- Add_Action (Table.States (57), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (303, 2), 1, null, null);
- Table.States (57).Kernel := To_Vector ((0 => (303, 190, 0,
False)));
- Table.States (57).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 303, 1)));
- Table.States (58).Action_List.Set_Capacity (40);
- Add_Action (Table.States (58), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (157, 5), 1, null,
- null);
- Table.States (58).Kernel := To_Vector ((0 => (157, 193, 0,
False)));
- Table.States (58).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 157, 1)));
- Table.States (59).Action_List.Set_Capacity (46);
- Add_Action (Table.States (59), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (151, 4), 1, null, null);
- Table.States (59).Kernel := To_Vector ((0 => (151, 196, 0,
False)));
- Table.States (59).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 151, 1)));
- Table.States (60).Action_List.Set_Capacity (40);
- Add_Action (Table.States (60), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (325, 0), 1, null,
- null);
- Table.States (60).Kernel := To_Vector ((0 => (325, 206, 0,
False)));
- Table.States (60).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 325, 1)));
- Table.States (61).Action_List.Set_Capacity (3);
- Add_Action (Table.States (61), (35, 74, 96), (312, 1), 1, null,
subprogram_specification_1_check'Access);
- Table.States (61).Kernel := To_Vector ((0 => (312, 207, 0,
False)));
- Table.States (61).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 312, 1)));
- Table.States (62).Action_List.Set_Capacity (40);
- Add_Action (Table.States (62), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (157, 6), 1, null,
- null);
- Table.States (62).Kernel := To_Vector ((0 => (157, 209, 0,
False)));
- Table.States (62).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 157, 1)));
- Table.States (63).Action_List.Set_Capacity (3);
- Add_Action (Table.States (63), 29, 7);
- Add_Action (Table.States (63), 47, 230);
- Add_Action (Table.States (63), 50, 18);
- Table.States (63).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (63), 207, 61);
- Add_Goto (Table.States (63), 251, 231);
- Add_Goto (Table.States (63), 262, 87);
- Add_Goto (Table.States (63), 312, 232);
- Table.States (63).Kernel := To_Vector (((214, 210, 5, False),
(216, 210, 3, False)));
- Table.States (63).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 50, 18)));
- Table.States (64).Action_List.Set_Capacity (40);
- Add_Action (Table.States (64), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (157, 7), 1, null,
- null);
- Table.States (64).Kernel := To_Vector ((0 => (157, 213, 0,
False)));
- Table.States (64).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 157, 1)));
- Table.States (65).Action_List.Set_Capacity (40);
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73,
74, 79, 94, 105, 106, 107, 108), (122, 1),
+ 1, null, null);
+ Table.States (56).Kernel := To_Vector ((0 => (122, 183, 0,
False)));
+ Table.States (56).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 1)));
+ Table.States (57).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (57), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (158, 4), 1,
+ null, null);
+ Table.States (57).Kernel := To_Vector ((0 => (158, 187, 0,
False)));
+ Table.States (57).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 158, 1)));
+ Table.States (58).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (58), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (304, 2), 1, null, null);
+ Table.States (58).Kernel := To_Vector ((0 => (304, 191, 0,
False)));
+ Table.States (58).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 304, 1)));
+ Table.States (59).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (59), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (158, 5), 1,
+ null, null);
+ Table.States (59).Kernel := To_Vector ((0 => (158, 194, 0,
False)));
+ Table.States (59).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 158, 1)));
+ Table.States (60).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (60), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (152, 4), 1, null, null);
+ Table.States (60).Kernel := To_Vector ((0 => (152, 197, 0,
False)));
+ Table.States (60).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 152, 1)));
+ Table.States (61).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (61), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (326, 0), 1,
+ null, null);
+ Table.States (61).Kernel := To_Vector ((0 => (326, 207, 0,
False)));
+ Table.States (61).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 326, 1)));
+ Table.States (62).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (62), (35, 74, 97), (313, 1), 1, null,
subprogram_specification_1_check'Access);
+ Table.States (62).Kernel := To_Vector ((0 => (313, 208, 0,
False)));
+ Table.States (62).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 313, 1)));
+ Table.States (63).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (63), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (158, 6), 1,
+ null, null);
+ Table.States (63).Kernel := To_Vector ((0 => (158, 210, 0,
False)));
+ Table.States (63).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 158, 1)));
+ Table.States (64).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (64), 29, 7);
+ Add_Action (Table.States (64), 47, 231);
+ Add_Action (Table.States (64), 50, 18);
+ Table.States (64).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (64), 208, 62);
+ Add_Goto (Table.States (64), 252, 232);
+ Add_Goto (Table.States (64), 263, 88);
+ Add_Goto (Table.States (64), 313, 233);
+ Table.States (64).Kernel := To_Vector (((215, 211, 5, False),
(217, 211, 3, False)));
+ Table.States (64).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 50, 18)));
+ Table.States (65).Action_List.Set_Capacity (41);
Add_Action (Table.States (65), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (209, 1), 1, null,
- null);
- Table.States (65).Kernel := To_Vector ((0 => (209, 214, 0,
False)));
- Table.States (65).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 209, 1)));
- Table.States (66).Action_List.Set_Capacity (40);
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (158, 7), 1,
+ null, null);
+ Table.States (65).Kernel := To_Vector ((0 => (158, 214, 0,
False)));
+ Table.States (65).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 158, 1)));
+ Table.States (66).Action_List.Set_Capacity (41);
Add_Action (Table.States (66), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (289, 3), 1, null,
- null);
- Table.States (66).Kernel := To_Vector ((0 => (289, 215, 0,
False)));
- Table.States (66).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 289, 1)));
- Table.States (67).Action_List.Set_Capacity (40);
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (210, 1), 1,
+ null, null);
+ Table.States (66).Kernel := To_Vector ((0 => (210, 215, 0,
False)));
+ Table.States (66).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 210, 1)));
+ Table.States (67).Action_List.Set_Capacity (41);
Add_Action (Table.States (67), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (209, 0), 1, null,
- null);
- Table.States (67).Kernel := To_Vector ((0 => (209, 216, 0,
False)));
- Table.States (67).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 209, 1)));
- Table.States (68).Action_List.Set_Capacity (46);
- Add_Action (Table.States (68), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (306, 0), 1, null, null);
- Table.States (68).Kernel := To_Vector ((0 => (306, 217, 0,
False)));
- Table.States (68).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 306, 1)));
- Table.States (69).Action_List.Set_Capacity (2);
- Add_Action (Table.States (69), 81, 233);
- Add_Action (Table.States (69), 83, 234);
- Table.States (69).Kernel := To_Vector (((157, 219, 4, False),
(186, 219, 3, False), (219, 219, 2, True),
- (244, 219, 4, False), (244, 219, 5, False), (244, 219, 11, False),
(244, 219, 3, False), (244, 219, 4,
- False), (244, 219, 10, False)));
- Table.States (69).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 81, 233)));
- Table.States (70).Action_List.Set_Capacity (46);
- Add_Action (Table.States (70), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (151, 0), 1, null, null);
- Table.States (70).Kernel := To_Vector ((0 => (151, 222, 0,
False)));
- Table.States (70).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 151, 1)));
- Table.States (71).Action_List.Set_Capacity (40);
- Add_Action (Table.States (71), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (325, 1), 1, null,
- null);
- Table.States (71).Kernel := To_Vector ((0 => (325, 223, 0,
False)));
- Table.States (71).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 325, 1)));
- Table.States (72).Action_List.Set_Capacity (46);
- Add_Action (Table.States (72), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (151, 2), 1, null, null);
- Table.States (72).Kernel := To_Vector ((0 => (151, 232, 0,
False)));
- Table.States (72).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 151, 1)));
- Table.States (73).Action_List.Set_Capacity (6);
- Add_Action (Table.States (73), 76, 235);
- Add_Action (Table.States (73), 82, 236);
- Add_Action (Table.States (73), 84, 237);
- Add_Action (Table.States (73), 96, 238);
- Add_Action (Table.States (73), 101, 239);
- Add_Action (Table.States (73), 102, 240);
- Table.States (73).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (73), 115, 241);
- Add_Goto (Table.States (73), 322, 242);
- Table.States (73).Kernel := To_Vector (((123, 239, 2, False),
(128, 239, 2, True), (239, 239, 5, True),
- (239, 239, 2, True), (261, 239, 1, False), (272, 239, 3, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True), (293, 239, 2, True)));
- Table.States (73).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 238)));
- Table.States (74).Action_List.Set_Capacity (40);
- Add_Action (Table.States (74), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (157, 8), 1, null,
- null);
- Table.States (74).Kernel := To_Vector ((0 => (157, 243, 0,
False)));
- Table.States (74).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 157, 1)));
- Table.States (75).Action_List.Set_Capacity (40);
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (290, 3), 1,
+ null, null);
+ Table.States (67).Kernel := To_Vector ((0 => (290, 216, 0,
False)));
+ Table.States (67).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 290, 1)));
+ Table.States (68).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (68), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (210, 0), 1,
+ null, null);
+ Table.States (68).Kernel := To_Vector ((0 => (210, 217, 0,
False)));
+ Table.States (68).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 210, 1)));
+ Table.States (69).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (69), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (307, 0), 1, null, null);
+ Table.States (69).Kernel := To_Vector ((0 => (307, 218, 0,
False)));
+ Table.States (69).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 307, 1)));
+ Table.States (70).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (70), 82, 234);
+ Add_Action (Table.States (70), 84, 235);
+ Table.States (70).Kernel := To_Vector (((158, 220, 4, False),
(187, 220, 3, False), (220, 220, 2, True),
+ (245, 220, 4, False), (245, 220, 5, False), (245, 220, 11, False),
(245, 220, 3, False), (245, 220, 4,
+ False), (245, 220, 10, False)));
+ Table.States (70).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 82, 234)));
+ Table.States (71).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (71), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (152, 0), 1, null, null);
+ Table.States (71).Kernel := To_Vector ((0 => (152, 223, 0,
False)));
+ Table.States (71).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 152, 1)));
+ Table.States (72).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (72), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (326, 1), 1,
+ null, null);
+ Table.States (72).Kernel := To_Vector ((0 => (326, 224, 0,
False)));
+ Table.States (72).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 326, 1)));
+ Table.States (73).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (73), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (152, 2), 1, null, null);
+ Table.States (73).Kernel := To_Vector ((0 => (152, 233, 0,
False)));
+ Table.States (73).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 152, 1)));
+ Table.States (74).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (74), 76, 236);
+ Add_Action (Table.States (74), 83, 237);
+ Add_Action (Table.States (74), 85, 238);
+ Add_Action (Table.States (74), 97, 239);
+ Add_Action (Table.States (74), 102, 240);
+ Add_Action (Table.States (74), 103, 241);
+ Table.States (74).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (74), 116, 242);
+ Add_Goto (Table.States (74), 323, 243);
+ Table.States (74).Kernel := To_Vector (((124, 240, 2, False),
(129, 240, 2, True), (240, 240, 5, True),
+ (240, 240, 2, True), (262, 240, 1, False), (273, 240, 3, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True), (294, 240, 2, True)));
+ Table.States (74).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 239)));
+ Table.States (75).Action_List.Set_Capacity (41);
Add_Action (Table.States (75), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (157, 10), 1,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (158, 8), 1,
null, null);
- Table.States (75).Kernel := To_Vector ((0 => (157, 244, 0,
False)));
- Table.States (75).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 157, 1)));
- Table.States (76).Action_List.Set_Capacity (40);
+ Table.States (75).Kernel := To_Vector ((0 => (158, 244, 0,
False)));
+ Table.States (75).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 158, 1)));
+ Table.States (76).Action_List.Set_Capacity (41);
Add_Action (Table.States (76), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (289, 0), 1, null,
- null);
- Table.States (76).Kernel := To_Vector ((0 => (289, 245, 0,
False)));
- Table.States (76).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 289, 1)));
- Table.States (77).Action_List.Set_Capacity (3);
- Add_Action (Table.States (77), 25, 243);
- Add_Action (Table.States (77), 29, 244);
- Add_Action (Table.States (77), 50, 245);
- Table.States (77).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (77), 207, 246);
- Add_Goto (Table.States (77), 262, 247);
- Add_Goto (Table.States (77), 312, 248);
- Table.States (77).Kernel := To_Vector (((112, 246, 5, False),
(179, 246, 6, False), (179, 246, 3, False),
- (193, 246, 7, False), (213, 246, 6, False), (213, 246, 6, False),
(243, 246, 5, False), (307, 246, 6,
- False), (308, 246, 5, False), (309, 246, 3, False), (311, 246, 5,
False)));
- Table.States (77).Minimal_Complete_Actions := To_Vector (((Shift,
25, 243), (Shift, 50, 245)));
- Table.States (78).Action_List.Set_Capacity (40);
- Add_Action (Table.States (78), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (263, 1), 1, null,
- null);
- Table.States (78).Kernel := To_Vector ((0 => (263, 247, 0,
False)));
- Table.States (78).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 263, 1)));
- Table.States (79).Action_List.Set_Capacity (40);
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (158, 10), 1,
+ null, null);
+ Table.States (76).Kernel := To_Vector ((0 => (158, 245, 0,
False)));
+ Table.States (76).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 158, 1)));
+ Table.States (77).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (77), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (290, 0), 1,
+ null, null);
+ Table.States (77).Kernel := To_Vector ((0 => (290, 246, 0,
False)));
+ Table.States (77).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 290, 1)));
+ Table.States (78).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (78), 25, 244);
+ Add_Action (Table.States (78), 29, 245);
+ Add_Action (Table.States (78), 50, 246);
+ Table.States (78).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (78), 208, 247);
+ Add_Goto (Table.States (78), 263, 248);
+ Add_Goto (Table.States (78), 313, 249);
+ Table.States (78).Kernel := To_Vector (((113, 247, 5, False),
(180, 247, 6, False), (180, 247, 3, False),
+ (194, 247, 7, False), (214, 247, 6, False), (214, 247, 6, False),
(244, 247, 5, False), (308, 247, 6,
+ False), (309, 247, 5, False), (310, 247, 3, False), (312, 247, 5,
False)));
+ Table.States (78).Minimal_Complete_Actions := To_Vector (((Shift,
25, 244), (Shift, 50, 246)));
+ Table.States (79).Action_List.Set_Capacity (41);
Add_Action (Table.States (79), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (135, 1), 1, null,
- null);
- Table.States (79).Kernel := To_Vector ((0 => (135, 248, 0,
False)));
- Table.States (79).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 135, 1)));
- Table.States (80).Action_List.Set_Capacity (40);
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (264, 1), 1,
+ null, null);
+ Table.States (79).Kernel := To_Vector ((0 => (264, 248, 0,
False)));
+ Table.States (79).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 264, 1)));
+ Table.States (80).Action_List.Set_Capacity (41);
Add_Action (Table.States (80), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (157, 11), 1,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (136, 1), 1,
null, null);
- Table.States (80).Kernel := To_Vector ((0 => (157, 249, 0,
False)));
- Table.States (80).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 157, 1)));
- Table.States (81).Action_List.Set_Capacity (40);
+ Table.States (80).Kernel := To_Vector ((0 => (136, 249, 0,
False)));
+ Table.States (80).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 136, 1)));
+ Table.States (81).Action_List.Set_Capacity (41);
Add_Action (Table.States (81), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (289, 1), 1, null,
- null);
- Table.States (81).Kernel := To_Vector ((0 => (289, 250, 0,
False)));
- Table.States (81).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 289, 1)));
- Table.States (82).Action_List.Set_Capacity (1);
- Add_Action (Table.States (82), 96, 249);
- Table.States (82).Kernel := To_Vector ((0 => (249, 251, 1,
False)));
- Table.States (82).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 249)));
- Table.States (83).Action_List.Set_Capacity (46);
- Add_Action (Table.States (83), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (303, 10), 1, null, null);
- Table.States (83).Kernel := To_Vector ((0 => (303, 257, 0,
False)));
- Table.States (83).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 303, 1)));
- Table.States (84).Action_List.Set_Capacity (40);
- Add_Action (Table.States (84), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (325, 3), 1, null,
- null);
- Table.States (84).Kernel := To_Vector ((0 => (325, 259, 0,
False)));
- Table.States (84).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 325, 1)));
- Table.States (85).Action_List.Set_Capacity (40);
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (158, 11), 1,
+ null, null);
+ Table.States (81).Kernel := To_Vector ((0 => (158, 250, 0,
False)));
+ Table.States (81).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 158, 1)));
+ Table.States (82).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (82), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (290, 1), 1,
+ null, null);
+ Table.States (82).Kernel := To_Vector ((0 => (290, 251, 0,
False)));
+ Table.States (82).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 290, 1)));
+ Table.States (83).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (83), 97, 250);
+ Table.States (83).Kernel := To_Vector ((0 => (250, 252, 1,
False)));
+ Table.States (83).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 250)));
+ Table.States (84).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (84), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (304, 10), 1, null, null);
+ Table.States (84).Kernel := To_Vector ((0 => (304, 258, 0,
False)));
+ Table.States (84).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 304, 1)));
+ Table.States (85).Action_List.Set_Capacity (41);
Add_Action (Table.States (85), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (325, 2), 1, null,
- null);
- Table.States (85).Kernel := To_Vector ((0 => (325, 260, 0,
False)));
- Table.States (85).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 325, 1)));
- Table.States (86).Action_List.Set_Capacity (46);
- Add_Action (Table.States (86), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (303, 4), 1, null, null);
- Table.States (86).Kernel := To_Vector ((0 => (303, 261, 0,
False)));
- Table.States (86).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 303, 1)));
- Table.States (87).Action_List.Set_Capacity (3);
- Add_Action (Table.States (87), (35, 74, 96), (312, 0), 1, null,
subprogram_specification_0_check'Access);
- Table.States (87).Kernel := To_Vector ((0 => (312, 262, 0,
False)));
- Table.States (87).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 312, 1)));
- Table.States (88).Action_List.Set_Capacity (40);
- Add_Action (Table.States (88), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (134, 0), 1, null,
- null);
- Table.States (88).Kernel := To_Vector ((0 => (134, 263, 0,
False)));
- Table.States (88).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 134, 1)));
- Table.States (89).Action_List.Set_Capacity (40);
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (326, 3), 1,
+ null, null);
+ Table.States (85).Kernel := To_Vector ((0 => (326, 260, 0,
False)));
+ Table.States (85).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 326, 1)));
+ Table.States (86).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (86), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (326, 2), 1,
+ null, null);
+ Table.States (86).Kernel := To_Vector ((0 => (326, 261, 0,
False)));
+ Table.States (86).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 326, 1)));
+ Table.States (87).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (87), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (304, 4), 1, null, null);
+ Table.States (87).Kernel := To_Vector ((0 => (304, 262, 0,
False)));
+ Table.States (87).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 304, 1)));
+ Table.States (88).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (88), (35, 74, 97), (313, 0), 1, null,
subprogram_specification_0_check'Access);
+ Table.States (88).Kernel := To_Vector ((0 => (313, 263, 0,
False)));
+ Table.States (88).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 313, 1)));
+ Table.States (89).Action_List.Set_Capacity (41);
Add_Action (Table.States (89), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (263, 3), 1, null,
- null);
- Table.States (89).Kernel := To_Vector ((0 => (263, 264, 0,
False)));
- Table.States (89).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 263, 1)));
- Table.States (90).Action_List.Set_Capacity (40);
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (135, 0), 1,
+ null, null);
+ Table.States (89).Kernel := To_Vector ((0 => (135, 264, 0,
False)));
+ Table.States (89).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 135, 1)));
+ Table.States (90).Action_List.Set_Capacity (41);
Add_Action (Table.States (90), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (135, 3), 1, null,
- null);
- Table.States (90).Kernel := To_Vector ((0 => (135, 265, 0,
False)));
- Table.States (90).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 135, 1)));
- Table.States (91).Action_List.Set_Capacity (40);
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (264, 3), 1,
+ null, null);
+ Table.States (90).Kernel := To_Vector ((0 => (264, 265, 0,
False)));
+ Table.States (90).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 264, 1)));
+ Table.States (91).Action_List.Set_Capacity (41);
Add_Action (Table.States (91), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (206, 2), 1, null,
- null);
- Table.States (91).Kernel := To_Vector ((0 => (206, 271, 0,
False)));
- Table.States (91).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 206, 1)));
- Table.States (92).Action_List.Set_Capacity (63);
- Add_Action (Table.States (92), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
- 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
- 88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104,
105, 106), (239, 4), 1, null, null);
- Table.States (92).Kernel := To_Vector ((0 => (239, 272, 0, True)));
- Table.States (92).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 239, 1)));
- Table.States (92).Minimal_Complete_Actions_Recursive := True;
- Table.States (93).Action_List.Set_Capacity (46);
- Add_Action (Table.States (93), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (303, 9), 1, null, null);
- Table.States (93).Kernel := To_Vector ((0 => (303, 276, 0,
False)));
- Table.States (93).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 303, 1)));
- Table.States (94).Action_List.Set_Capacity (41);
- Add_Action (Table.States (94), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73,
74, 93, 104, 105, 106, 107), (121, 2), 1,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (136, 3), 1,
null, null);
- Table.States (94).Kernel := To_Vector ((0 => (121, 281, 0,
False)));
- Table.States (94).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 121, 1)));
- Table.States (95).Action_List.Set_Capacity (40);
+ Table.States (91).Kernel := To_Vector ((0 => (136, 266, 0,
False)));
+ Table.States (91).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 136, 1)));
+ Table.States (92).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (92), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (207, 2), 1,
+ null, null);
+ Table.States (92).Kernel := To_Vector ((0 => (207, 272, 0,
False)));
+ Table.States (92).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 207, 1)));
+ Table.States (93).Action_List.Set_Capacity (64);
+ Add_Action (Table.States (93), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+ 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
105, 106, 107), (240, 4), 1, null, null);
+ Table.States (93).Kernel := To_Vector ((0 => (240, 273, 0, True)));
+ Table.States (93).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 240, 1)));
+ Table.States (93).Minimal_Complete_Actions_Recursive := True;
+ Table.States (94).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (94), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (304, 9), 1, null, null);
+ Table.States (94).Kernel := To_Vector ((0 => (304, 277, 0,
False)));
+ Table.States (94).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 304, 1)));
+ Table.States (95).Action_List.Set_Capacity (42);
Add_Action (Table.States (95), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (157, 12), 1,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73,
74, 79, 94, 105, 106, 107, 108), (122, 2),
+ 1, null, null);
+ Table.States (95).Kernel := To_Vector ((0 => (122, 282, 0,
False)));
+ Table.States (95).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 1)));
+ Table.States (96).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (96), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (158, 12), 1,
null, null);
- Table.States (95).Kernel := To_Vector ((0 => (157, 289, 0,
False)));
- Table.States (95).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 157, 1)));
- Table.States (96).Action_List.Set_Capacity (46);
- Add_Action (Table.States (96), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (303, 6), 1, null, null);
- Table.States (96).Kernel := To_Vector ((0 => (303, 290, 0,
False)));
- Table.States (96).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 303, 1)));
- Table.States (97).Action_List.Set_Capacity (63);
- Add_Action (Table.States (97), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
- 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
- 88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104,
105, 106), (239, 2), 1, null,
+ Table.States (96).Kernel := To_Vector ((0 => (158, 290, 0,
False)));
+ Table.States (96).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 158, 1)));
+ Table.States (97).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (97), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (304, 6), 1, null, null);
+ Table.States (97).Kernel := To_Vector ((0 => (304, 291, 0,
False)));
+ Table.States (97).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 304, 1)));
+ Table.States (98).Action_List.Set_Capacity (64);
+ Add_Action (Table.States (98), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+ 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
105, 106, 107), (240, 2), 1, null,
name_2_check'Access);
- Table.States (97).Kernel := To_Vector ((0 => (239, 293, 0, True)));
- Table.States (97).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 239, 1)));
- Table.States (97).Minimal_Complete_Actions_Recursive := True;
- Table.States (98).Action_List.Set_Capacity (46);
- Add_Action (Table.States (98), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (298, 0), 1, null, null);
- Table.States (98).Kernel := To_Vector ((0 => (298, 294, 0,
False)));
- Table.States (98).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 298, 1)));
- Table.States (99).Action_List.Set_Capacity (46);
+ Table.States (98).Kernel := To_Vector ((0 => (240, 294, 0, True)));
+ Table.States (98).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 240, 1)));
+ Table.States (98).Minimal_Complete_Actions_Recursive := True;
+ Table.States (99).Action_List.Set_Capacity (47);
Add_Action (Table.States (99), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (151, 6), 1, null, null);
- Table.States (99).Kernel := To_Vector ((0 => (151, 298, 0,
False)));
- Table.States (99).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 151, 1)));
- Table.States (100).Action_List.Set_Capacity (46);
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (299, 0), 1, null, null);
+ Table.States (99).Kernel := To_Vector ((0 => (299, 295, 0,
False)));
+ Table.States (99).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 299, 1)));
+ Table.States (100).Action_List.Set_Capacity (47);
Add_Action (Table.States (100), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (303, 5), 1, null, null);
- Table.States (100).Kernel := To_Vector ((0 => (303, 302, 0,
False)));
- Table.States (100).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 303, 1)));
- Table.States (101).Action_List.Set_Capacity (46);
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (152, 6), 1, null, null);
+ Table.States (100).Kernel := To_Vector ((0 => (152, 299, 0,
False)));
+ Table.States (100).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 152, 1)));
+ Table.States (101).Action_List.Set_Capacity (47);
Add_Action (Table.States (101), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (306, 1), 1, null, null);
- Table.States (101).Kernel := To_Vector ((0 => (306, 303, 0,
False)));
- Table.States (101).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 306, 1)));
- Table.States (102).Action_List.Set_Capacity (40);
- Add_Action (Table.States (102), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (244, 7), 1, null,
- null);
- Table.States (102).Kernel := To_Vector ((0 => (244, 304, 0,
False)));
- Table.States (102).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 244, 1)));
- Table.States (103).Action_List.Set_Capacity (40);
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (304, 5), 1, null, null);
+ Table.States (101).Kernel := To_Vector ((0 => (304, 303, 0,
False)));
+ Table.States (101).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 304, 1)));
+ Table.States (102).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (102), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (307, 1), 1, null, null);
+ Table.States (102).Kernel := To_Vector ((0 => (307, 304, 0,
False)));
+ Table.States (102).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 307, 1)));
+ Table.States (103).Action_List.Set_Capacity (41);
Add_Action (Table.States (103), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (244, 6), 1, null,
- null);
- Table.States (103).Kernel := To_Vector ((0 => (244, 305, 0,
False)));
- Table.States (103).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 244, 1)));
- Table.States (104).Action_List.Set_Capacity (39);
- Add_Action (Table.States (104), (4, 5, 13, 15, 17, 18, 25, 27, 28,
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
- 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93,
104, 105, 106, 107), (142, 4), 1, null,
- null);
- Table.States (104).Kernel := To_Vector ((0 => (142, 306, 0,
False)));
- Table.States (104).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 142, 1)));
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (245, 7), 1,
+ null, null);
+ Table.States (103).Kernel := To_Vector ((0 => (245, 305, 0,
False)));
+ Table.States (103).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 245, 1)));
+ Table.States (104).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (104), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (245, 6), 1,
+ null, null);
+ Table.States (104).Kernel := To_Vector ((0 => (245, 306, 0,
False)));
+ Table.States (104).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 245, 1)));
Table.States (105).Action_List.Set_Capacity (40);
- Add_Action (Table.States (105), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (263, 0), 1, null,
+ Add_Action (Table.States (105), (4, 5, 13, 15, 17, 18, 25, 27, 28,
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
+ 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 79,
94, 105, 106, 107, 108), (143, 4), 1, null,
null);
- Table.States (105).Kernel := To_Vector ((0 => (263, 307, 0,
False)));
- Table.States (105).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 263, 1)));
- Table.States (106).Action_List.Set_Capacity (40);
+ Table.States (105).Kernel := To_Vector ((0 => (143, 307, 0,
False)));
+ Table.States (105).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 143, 1)));
+ Table.States (106).Action_List.Set_Capacity (41);
Add_Action (Table.States (106), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (135, 0), 1, null,
- null);
- Table.States (106).Kernel := To_Vector ((0 => (135, 308, 0,
False)));
- Table.States (106).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 135, 1)));
- Table.States (107).Action_List.Set_Capacity (40);
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (264, 0), 1,
+ null, null);
+ Table.States (106).Kernel := To_Vector ((0 => (264, 308, 0,
False)));
+ Table.States (106).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 264, 1)));
+ Table.States (107).Action_List.Set_Capacity (41);
Add_Action (Table.States (107), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (157, 13), 1,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (136, 0), 1,
null, null);
- Table.States (107).Kernel := To_Vector ((0 => (157, 309, 0,
False)));
- Table.States (107).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 157, 1)));
- Table.States (108).Action_List.Set_Capacity (40);
+ Table.States (107).Kernel := To_Vector ((0 => (136, 309, 0,
False)));
+ Table.States (107).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 136, 1)));
+ Table.States (108).Action_List.Set_Capacity (41);
Add_Action (Table.States (108), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (289, 2), 1, null,
- null);
- Table.States (108).Kernel := To_Vector ((0 => (289, 311, 0,
False)));
- Table.States (108).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 289, 1)));
- Table.States (109).Action_List.Set_Capacity (40);
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (158, 13), 1,
+ null, null);
+ Table.States (108).Kernel := To_Vector ((0 => (158, 310, 0,
False)));
+ Table.States (108).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 158, 1)));
+ Table.States (109).Action_List.Set_Capacity (41);
Add_Action (Table.States (109), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (157, 14), 1,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (290, 2), 1,
null, null);
- Table.States (109).Kernel := To_Vector ((0 => (157, 313, 0,
False)));
- Table.States (109).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 157, 1)));
- Table.States (110).Action_List.Set_Capacity (39);
- Add_Action (Table.States (110), (4, 5, 13, 15, 17, 18, 25, 27, 28,
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
- 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93,
104, 105, 106, 107), (142, 1), 1, null,
- null);
- Table.States (110).Kernel := To_Vector ((0 => (142, 315, 0,
False)));
- Table.States (110).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 142, 1)));
+ Table.States (109).Kernel := To_Vector ((0 => (290, 312, 0,
False)));
+ Table.States (109).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 290, 1)));
+ Table.States (110).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (110), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (158, 14), 1,
+ null, null);
+ Table.States (110).Kernel := To_Vector ((0 => (158, 314, 0,
False)));
+ Table.States (110).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 158, 1)));
Table.States (111).Action_List.Set_Capacity (40);
- Add_Action (Table.States (111), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (263, 2), 1, null,
+ Add_Action (Table.States (111), (4, 5, 13, 15, 17, 18, 25, 27, 28,
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
+ 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 79,
94, 105, 106, 107, 108), (143, 1), 1, null,
null);
- Table.States (111).Kernel := To_Vector ((0 => (263, 316, 0,
False)));
- Table.States (111).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 263, 1)));
- Table.States (112).Action_List.Set_Capacity (40);
+ Table.States (111).Kernel := To_Vector ((0 => (143, 316, 0,
False)));
+ Table.States (111).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 143, 1)));
+ Table.States (112).Action_List.Set_Capacity (41);
Add_Action (Table.States (112), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (135, 2), 1, null,
- null);
- Table.States (112).Kernel := To_Vector ((0 => (135, 317, 0,
False)));
- Table.States (112).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 135, 1)));
- Table.States (113).Action_List.Set_Capacity (40);
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (264, 2), 1,
+ null, null);
+ Table.States (112).Kernel := To_Vector ((0 => (264, 317, 0,
False)));
+ Table.States (112).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 264, 1)));
+ Table.States (113).Action_List.Set_Capacity (41);
Add_Action (Table.States (113), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (206, 1), 1, null,
- null);
- Table.States (113).Kernel := To_Vector ((0 => (206, 319, 0,
False)));
- Table.States (113).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 206, 1)));
- Table.States (114).Action_List.Set_Capacity (46);
- Add_Action (Table.States (114), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (298, 1), 1, null, null);
- Table.States (114).Kernel := To_Vector ((0 => (298, 323, 0,
False)));
- Table.States (114).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 298, 1)));
- Table.States (115).Action_List.Set_Capacity (40);
- Add_Action (Table.States (115), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (157, 15), 1,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (136, 2), 1,
null, null);
- Table.States (115).Kernel := To_Vector ((0 => (157, 325, 0,
False)));
- Table.States (115).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 157, 1)));
- Table.States (116).Action_List.Set_Capacity (40);
+ Table.States (113).Kernel := To_Vector ((0 => (136, 318, 0,
False)));
+ Table.States (113).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 136, 1)));
+ Table.States (114).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (114), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (207, 1), 1,
+ null, null);
+ Table.States (114).Kernel := To_Vector ((0 => (207, 320, 0,
False)));
+ Table.States (114).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 207, 1)));
+ Table.States (115).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (115), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (299, 1), 1, null, null);
+ Table.States (115).Kernel := To_Vector ((0 => (299, 324, 0,
False)));
+ Table.States (115).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 299, 1)));
+ Table.States (116).Action_List.Set_Capacity (41);
Add_Action (Table.States (116), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (157, 16), 1,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (158, 15), 1,
+ null, null);
+ Table.States (116).Kernel := To_Vector ((0 => (158, 326, 0,
False)));
+ Table.States (116).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 158, 1)));
+ Table.States (117).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (117), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (158, 16), 1,
null, null);
- Table.States (116).Kernel := To_Vector ((0 => (157, 331, 0,
False)));
- Table.States (116).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 157, 1)));
- Table.States (117).Action_List.Set_Capacity (39);
- Add_Action (Table.States (117), (4, 5, 13, 15, 17, 18, 25, 27, 28,
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
- 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93,
104, 105, 106, 107), (142, 0), 1, null,
+ Table.States (117).Kernel := To_Vector ((0 => (158, 332, 0,
False)));
+ Table.States (117).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 158, 1)));
+ Table.States (118).Action_List.Set_Capacity (40);
+ Add_Action (Table.States (118), (4, 5, 13, 15, 17, 18, 25, 27, 28,
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
+ 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 79,
94, 105, 106, 107, 108), (143, 0), 1, null,
null);
- Table.States (117).Kernel := To_Vector ((0 => (142, 332, 0,
False)));
- Table.States (117).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 142, 1)));
- Table.States (118).Action_List.Set_Capacity (3);
- Add_Action (Table.States (118), 21, Reduce, (116, 1), 0, null,
null);
- Add_Action (Table.States (118), 76, 250);
- Add_Conflict (Table.States (118), 76, (116, 1), 0, null, null);
- Add_Action (Table.States (118), 96, Reduce, (116, 1), 0, null,
null);
- Table.States (118).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (118), 115, 251);
- Add_Goto (Table.States (118), 116, 252);
- Table.States (118).Kernel := To_Vector (((113, 104, 3, False),
(113, 104, 1, False)));
- Table.States (118).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 116, 0)));
- Table.States (119).Action_List.Set_Capacity (62);
- Add_Action (Table.States (119), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
- 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 73, 74, 75,
76, 77, 78, 79, 82, 83, 84, 85, 86, 87, 88,
- 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105,
106), (239, 5), 1, name_5'Access,
+ Table.States (118).Kernel := To_Vector ((0 => (143, 333, 0,
False)));
+ Table.States (118).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 143, 1)));
+ Table.States (119).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (119), 21, Reduce, (117, 1), 0, null,
null);
+ Add_Action (Table.States (119), 76, 251);
+ Add_Conflict (Table.States (119), 76, (117, 1), 0, null, null);
+ Add_Action (Table.States (119), 97, Reduce, (117, 1), 0, null,
null);
+ Table.States (119).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (119), 116, 252);
+ Add_Goto (Table.States (119), 117, 253);
+ Table.States (119).Kernel := To_Vector (((114, 105, 3, False),
(114, 105, 1, False)));
+ Table.States (119).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 117, 0)));
+ Table.States (120).Action_List.Set_Capacity (63);
+ Add_Action (Table.States (120), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 73, 74, 75,
76, 77, 78, 79, 80, 83, 84, 85, 86, 87, 88,
+ 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 105,
106, 107), (240, 5), 1, name_5'Access,
name_5_check'Access);
- Table.States (119).Kernel := To_Vector ((0 => (239, 104, 0,
False)));
- Table.States (119).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 239, 1)));
- Table.States (120).Action_List.Set_Capacity (5);
- Add_Action (Table.States (120), 76, 235);
- Add_Action (Table.States (120), 84, 237);
- Add_Action (Table.States (120), 96, 253);
- Add_Action (Table.States (120), 101, 239);
- Add_Action (Table.States (120), 102, 240);
- Table.States (120).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (120), 115, 241);
- Add_Goto (Table.States (120), 322, 242);
- Table.States (120).Kernel := To_Vector (((128, 239, 2, True),
(239, 239, 5, True), (239, 239, 2, True),
- (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (303, 239, 1, False)));
- Table.States (120).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 253)));
- Table.States (121).Action_List.Set_Capacity (7);
- Add_Action (Table.States (121), 39, 122);
- Add_Action (Table.States (121), 41, 124);
- Add_Action (Table.States (121), 76, 126);
- Add_Action (Table.States (121), 103, 129);
- Add_Action (Table.States (121), 104, 119);
- Add_Action (Table.States (121), 105, 33);
- Add_Action (Table.States (121), 106, 34);
- Table.States (121).Goto_List.Set_Capacity (6);
- Add_Goto (Table.States (121), 117, 130);
- Add_Goto (Table.States (121), 128, 41);
- Add_Goto (Table.States (121), 239, 134);
- Add_Goto (Table.States (121), 258, 254);
- Add_Goto (Table.States (121), 272, 92);
- Add_Goto (Table.States (121), 293, 97);
- Table.States (121).Kernel := To_Vector ((0 => (197, 3, 1, False)));
- Table.States (121).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
- Table.States (122).Action_List.Set_Capacity (3);
- Add_Action (Table.States (122), 104, 119);
- Add_Action (Table.States (122), 105, 33);
+ Table.States (120).Kernel := To_Vector ((0 => (240, 105, 0,
False)));
+ Table.States (120).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 240, 1)));
+ Table.States (121).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (121), 76, 236);
+ Add_Action (Table.States (121), 85, 238);
+ Add_Action (Table.States (121), 97, 254);
+ Add_Action (Table.States (121), 102, 240);
+ Add_Action (Table.States (121), 103, 241);
+ Table.States (121).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (121), 116, 242);
+ Add_Goto (Table.States (121), 323, 243);
+ Table.States (121).Kernel := To_Vector (((129, 240, 2, True),
(240, 240, 5, True), (240, 240, 2, True),
+ (273, 240, 3, True), (294, 240, 2, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (304, 240, 1, False)));
+ Table.States (121).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 254)));
+ Table.States (122).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (122), 39, 123);
+ Add_Action (Table.States (122), 41, 125);
+ Add_Action (Table.States (122), 76, 127);
+ Add_Action (Table.States (122), 79, 31);
+ Add_Action (Table.States (122), 104, 130);
+ Add_Action (Table.States (122), 105, 120);
Add_Action (Table.States (122), 106, 34);
- Table.States (122).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (122), 128, 41);
- Add_Goto (Table.States (122), 239, 255);
- Add_Goto (Table.States (122), 272, 92);
- Add_Goto (Table.States (122), 293, 97);
- Table.States (122).Kernel := To_Vector ((0 => (258, 39, 1,
False)));
- Table.States (122).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (123).Action_List.Set_Capacity (7);
- Add_Action (Table.States (123), 39, 122);
- Add_Action (Table.States (123), 41, 124);
- Add_Action (Table.States (123), 76, 126);
- Add_Action (Table.States (123), 103, 129);
- Add_Action (Table.States (123), 104, 119);
- Add_Action (Table.States (123), 105, 33);
+ Add_Action (Table.States (122), 107, 35);
+ Table.States (122).Goto_List.Set_Capacity (6);
+ Add_Goto (Table.States (122), 118, 131);
+ Add_Goto (Table.States (122), 129, 42);
+ Add_Goto (Table.States (122), 240, 135);
+ Add_Goto (Table.States (122), 259, 255);
+ Add_Goto (Table.States (122), 273, 93);
+ Add_Goto (Table.States (122), 294, 98);
+ Table.States (122).Kernel := To_Vector ((0 => (198, 3, 1, False)));
+ Table.States (122).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
+ Table.States (123).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (123), 79, 31);
+ Add_Action (Table.States (123), 105, 120);
Add_Action (Table.States (123), 106, 34);
- Table.States (123).Goto_List.Set_Capacity (6);
- Add_Goto (Table.States (123), 117, 130);
- Add_Goto (Table.States (123), 128, 41);
- Add_Goto (Table.States (123), 239, 134);
- Add_Goto (Table.States (123), 258, 256);
- Add_Goto (Table.States (123), 272, 92);
- Add_Goto (Table.States (123), 293, 97);
- Table.States (123).Kernel := To_Vector ((0 => (197, 40, 1,
False)));
- Table.States (123).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
- Table.States (124).Action_List.Set_Capacity (36);
- Add_Action (Table.States (124), (10, 20, 21, 22, 23, 33, 35, 37,
38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
- 78, 79, 82, 83, 85, 86, 87, 88, 89, 91, 92, 94, 95, 96, 97, 98,
99, 100), (258, 1), 1, null, null);
- Table.States (124).Kernel := To_Vector ((0 => (258, 41, 0,
False)));
- Table.States (124).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 258, 1)));
- Table.States (125).Action_List.Set_Capacity (3);
- Add_Action (Table.States (125), 104, 119);
- Add_Action (Table.States (125), 105, 33);
- Add_Action (Table.States (125), 106, 34);
- Table.States (125).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (125), 128, 41);
- Add_Goto (Table.States (125), 239, 257);
- Add_Goto (Table.States (125), 272, 92);
- Add_Goto (Table.States (125), 293, 97);
- Table.States (125).Kernel := To_Vector (((275, 52, 2, True), (275,
52, 1, False)));
- Table.States (125).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (126).Action_List.Set_Capacity (21);
- Add_Action (Table.States (126), 3, 121);
- Add_Action (Table.States (126), 15, 258);
- Add_Action (Table.States (126), 28, 259);
- Add_Action (Table.States (126), 32, 260);
- Add_Action (Table.States (126), 39, 122);
- Add_Action (Table.States (126), 40, 261);
- Add_Action (Table.States (126), 41, 262);
- Add_Action (Table.States (126), 44, 263);
- Add_Action (Table.States (126), 52, 125);
- Add_Action (Table.States (126), 74, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (126), 76, 126);
- Add_Action (Table.States (126), 77, Reduce, (124, 5), 0, null,
null);
- Add_Action (Table.States (126), 79, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (126), 83, Reduce, (124, 5), 0, null,
null);
- Add_Action (Table.States (126), 87, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (126), 94, 127);
- Add_Action (Table.States (126), 95, 128);
- Add_Action (Table.States (126), 103, 129);
- Add_Action (Table.States (126), 104, 119);
- Add_Action (Table.States (126), 105, 33);
- Add_Action (Table.States (126), 106, 264);
- Table.States (126).Goto_List.Set_Capacity (29);
- Add_Goto (Table.States (126), 117, 130);
- Add_Goto (Table.States (126), 124, 265);
- Add_Goto (Table.States (126), 125, 266);
- Add_Goto (Table.States (126), 128, 41);
- Add_Goto (Table.States (126), 136, 267);
- Add_Goto (Table.States (126), 153, 268);
- Add_Goto (Table.States (126), 165, 269);
- Add_Goto (Table.States (126), 166, 270);
- Add_Goto (Table.States (126), 191, 271);
- Add_Goto (Table.States (126), 192, 272);
- Add_Goto (Table.States (126), 197, 133);
- Add_Goto (Table.States (126), 221, 273);
- Add_Goto (Table.States (126), 239, 274);
- Add_Goto (Table.States (126), 258, 135);
- Add_Goto (Table.States (126), 272, 92);
- Add_Goto (Table.States (126), 273, 275);
- Add_Goto (Table.States (126), 275, 136);
- Add_Goto (Table.States (126), 277, 276);
- Add_Goto (Table.States (126), 282, 137);
- Add_Goto (Table.States (126), 283, 138);
- Add_Goto (Table.States (126), 284, 139);
- Add_Goto (Table.States (126), 285, 140);
- Add_Goto (Table.States (126), 286, 141);
- Add_Goto (Table.States (126), 287, 142);
- Add_Goto (Table.States (126), 293, 97);
- Add_Goto (Table.States (126), 301, 277);
- Add_Goto (Table.States (126), 320, 144);
- Add_Goto (Table.States (126), 321, 145);
- Add_Goto (Table.States (126), 330, 146);
- Table.States (126).Kernel := To_Vector (((117, 76, 4, False),
(117, 76, 2, False), (117, 76, 3, False),
- (117, 76, 3, False), (117, 76, 1, False)));
- Table.States (126).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 125, 0)));
- Table.States (127).Action_List.Set_Capacity (9);
- Add_Action (Table.States (127), (3, 39, 40, 41, 76, 103, 104, 105,
106), (330, 1), 1, null, null);
- Table.States (127).Kernel := To_Vector ((0 => (330, 94, 0,
False)));
- Table.States (127).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 330, 1)));
- Table.States (128).Action_List.Set_Capacity (9);
- Add_Action (Table.States (128), (3, 39, 40, 41, 76, 103, 104, 105,
106), (330, 0), 1, null, null);
- Table.States (128).Kernel := To_Vector ((0 => (330, 95, 0,
False)));
- Table.States (128).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 330, 1)));
- Table.States (129).Action_List.Set_Capacity (36);
- Add_Action (Table.States (129), (10, 20, 21, 22, 23, 33, 35, 37,
38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
- 78, 79, 82, 83, 85, 86, 87, 88, 89, 91, 92, 94, 95, 96, 97, 98,
99, 100), (258, 0), 1, primary_0'Access,
- null);
- Table.States (129).Kernel := To_Vector ((0 => (258, 103, 0,
False)));
- Table.States (129).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 258, 1)));
+ Add_Action (Table.States (123), 107, 35);
+ Table.States (123).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (123), 129, 42);
+ Add_Goto (Table.States (123), 240, 256);
+ Add_Goto (Table.States (123), 273, 93);
+ Add_Goto (Table.States (123), 294, 98);
+ Table.States (123).Kernel := To_Vector ((0 => (259, 39, 1,
False)));
+ Table.States (123).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (124).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (124), 39, 123);
+ Add_Action (Table.States (124), 41, 125);
+ Add_Action (Table.States (124), 76, 127);
+ Add_Action (Table.States (124), 79, 31);
+ Add_Action (Table.States (124), 104, 130);
+ Add_Action (Table.States (124), 105, 120);
+ Add_Action (Table.States (124), 106, 34);
+ Add_Action (Table.States (124), 107, 35);
+ Table.States (124).Goto_List.Set_Capacity (6);
+ Add_Goto (Table.States (124), 118, 131);
+ Add_Goto (Table.States (124), 129, 42);
+ Add_Goto (Table.States (124), 240, 135);
+ Add_Goto (Table.States (124), 259, 257);
+ Add_Goto (Table.States (124), 273, 93);
+ Add_Goto (Table.States (124), 294, 98);
+ Table.States (124).Kernel := To_Vector ((0 => (198, 40, 1,
False)));
+ Table.States (124).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
+ Table.States (125).Action_List.Set_Capacity (36);
+ Add_Action (Table.States (125), (10, 20, 21, 22, 23, 33, 35, 37,
38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
+ 78, 80, 83, 84, 86, 87, 88, 89, 90, 92, 93, 95, 96, 97, 98, 99,
100, 101), (259, 1), 1, null, null);
+ Table.States (125).Kernel := To_Vector ((0 => (259, 41, 0,
False)));
+ Table.States (125).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 259, 1)));
+ Table.States (126).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (126), 79, 31);
+ Add_Action (Table.States (126), 105, 120);
+ Add_Action (Table.States (126), 106, 34);
+ Add_Action (Table.States (126), 107, 35);
+ Table.States (126).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (126), 129, 42);
+ Add_Goto (Table.States (126), 240, 258);
+ Add_Goto (Table.States (126), 273, 93);
+ Add_Goto (Table.States (126), 294, 98);
+ Table.States (126).Kernel := To_Vector (((276, 52, 2, True), (276,
52, 1, False)));
+ Table.States (126).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (127).Action_List.Set_Capacity (22);
+ Add_Action (Table.States (127), 3, 122);
+ Add_Action (Table.States (127), 15, 259);
+ Add_Action (Table.States (127), 28, 260);
+ Add_Action (Table.States (127), 32, 261);
+ Add_Action (Table.States (127), 39, 123);
+ Add_Action (Table.States (127), 40, 262);
+ Add_Action (Table.States (127), 41, 263);
+ Add_Action (Table.States (127), 44, 264);
+ Add_Action (Table.States (127), 52, 126);
+ Add_Action (Table.States (127), 74, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (127), 76, 127);
+ Add_Action (Table.States (127), 77, Reduce, (125, 6), 0, null,
null);
+ Add_Action (Table.States (127), 79, 31);
+ Add_Action (Table.States (127), 80, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (127), 84, Reduce, (125, 6), 0, null,
null);
+ Add_Action (Table.States (127), 88, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (127), 95, 128);
+ Add_Action (Table.States (127), 96, 129);
+ Add_Action (Table.States (127), 104, 130);
+ Add_Action (Table.States (127), 105, 120);
+ Add_Action (Table.States (127), 106, 34);
+ Add_Action (Table.States (127), 107, 265);
+ Table.States (127).Goto_List.Set_Capacity (29);
+ Add_Goto (Table.States (127), 118, 131);
+ Add_Goto (Table.States (127), 125, 266);
+ Add_Goto (Table.States (127), 126, 267);
+ Add_Goto (Table.States (127), 129, 42);
+ Add_Goto (Table.States (127), 137, 268);
+ Add_Goto (Table.States (127), 154, 269);
+ Add_Goto (Table.States (127), 166, 270);
+ Add_Goto (Table.States (127), 167, 271);
+ Add_Goto (Table.States (127), 192, 272);
+ Add_Goto (Table.States (127), 193, 273);
+ Add_Goto (Table.States (127), 198, 134);
+ Add_Goto (Table.States (127), 222, 274);
+ Add_Goto (Table.States (127), 240, 275);
+ Add_Goto (Table.States (127), 259, 136);
+ Add_Goto (Table.States (127), 273, 93);
+ Add_Goto (Table.States (127), 274, 276);
+ Add_Goto (Table.States (127), 276, 137);
+ Add_Goto (Table.States (127), 278, 277);
+ Add_Goto (Table.States (127), 283, 138);
+ Add_Goto (Table.States (127), 284, 139);
+ Add_Goto (Table.States (127), 285, 140);
+ Add_Goto (Table.States (127), 286, 141);
+ Add_Goto (Table.States (127), 287, 142);
+ Add_Goto (Table.States (127), 288, 143);
+ Add_Goto (Table.States (127), 294, 98);
+ Add_Goto (Table.States (127), 302, 278);
+ Add_Goto (Table.States (127), 321, 145);
+ Add_Goto (Table.States (127), 322, 146);
+ Add_Goto (Table.States (127), 331, 147);
+ Table.States (127).Kernel := To_Vector (((118, 76, 4, False),
(118, 76, 2, False), (118, 76, 3, False),
+ (118, 76, 4, False), (118, 76, 3, False), (118, 76, 1, False)));
+ Table.States (127).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 126, 0)));
+ Table.States (128).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (128), (3, 39, 40, 41, 76, 79, 104, 105,
106, 107), (331, 1), 1, null, null);
+ Table.States (128).Kernel := To_Vector ((0 => (331, 95, 0,
False)));
+ Table.States (128).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 331, 1)));
+ Table.States (129).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (129), (3, 39, 40, 41, 76, 79, 104, 105,
106, 107), (331, 0), 1, null, null);
+ Table.States (129).Kernel := To_Vector ((0 => (331, 96, 0,
False)));
+ Table.States (129).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 331, 1)));
Table.States (130).Action_List.Set_Capacity (36);
Add_Action (Table.States (130), (10, 20, 21, 22, 23, 33, 35, 37,
38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
- 78, 79, 82, 83, 85, 86, 87, 88, 89, 91, 92, 94, 95, 96, 97, 98,
99, 100), (258, 2), 1, primary_2'Access,
+ 78, 80, 83, 84, 86, 87, 88, 89, 90, 92, 93, 95, 96, 97, 98, 99,
100, 101), (259, 0), 1, primary_0'Access,
null);
- Table.States (130).Kernel := To_Vector ((0 => (258, 117, 0,
False)));
- Table.States (130).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 258, 1)));
- Table.States (131).Action_List.Set_Capacity (17);
- Add_Action (Table.States (131), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 79, 83, 87, 96), (192,
+ Table.States (130).Kernel := To_Vector ((0 => (259, 104, 0,
False)));
+ Table.States (130).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 259, 1)));
+ Table.States (131).Action_List.Set_Capacity (36);
+ Add_Action (Table.States (131), (10, 20, 21, 22, 23, 33, 35, 37,
38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
+ 78, 80, 83, 84, 86, 87, 88, 89, 90, 92, 93, 95, 96, 97, 98, 99,
100, 101), (259, 2), 1, primary_2'Access,
+ null);
+ Table.States (131).Kernel := To_Vector ((0 => (259, 118, 0,
False)));
+ Table.States (131).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 259, 1)));
+ Table.States (132).Action_List.Set_Capacity (17);
+ Add_Action (Table.States (132), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 80, 84, 88, 97), (193,
0), 1, null, null);
- Table.States (131).Kernel := To_Vector ((0 => (192, 191, 0,
True)));
- Table.States (131).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 1)));
- Table.States (131).Minimal_Complete_Actions_Recursive := True;
- Table.States (132).Action_List.Set_Capacity (1);
- Add_Action (Table.States (132), 35, 278);
- Table.States (132).Kernel := To_Vector ((0 => (139, 192, 6,
False)));
- Table.States (132).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 278)));
- Table.States (133).Action_List.Set_Capacity (35);
- Add_Action (Table.States (133), (10, 20, 21, 22, 23, 33, 35, 37,
38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
- 78, 79, 82, 83, 85, 86, 87, 88, 89, 91, 92, 94, 95, 96, 97, 98,
99), (320, 1), 1, null, null);
- Table.States (133).Kernel := To_Vector ((0 => (320, 197, 0,
False)));
- Table.States (133).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 320, 1)));
- Table.States (134).Action_List.Set_Capacity (40);
- Add_Action (Table.States (134), 10, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 20, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 21, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 22, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 23, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 33, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 35, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 37, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 38, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 40, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 42, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 43, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 53, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 55, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 68, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 74, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 75, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 76, 235);
- Add_Action (Table.States (134), 77, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 78, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 79, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 82, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 83, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 84, 237);
- Add_Action (Table.States (134), 85, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 86, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 87, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 88, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 89, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 91, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 92, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 94, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 95, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 96, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 97, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 98, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 99, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 100, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (134), 101, 239);
- Add_Action (Table.States (134), 102, 240);
- Table.States (134).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (134), 115, 241);
- Add_Goto (Table.States (134), 322, 242);
- Table.States (134).Kernel := To_Vector (((128, 239, 2, True),
(239, 239, 5, True), (239, 239, 2, True),
- (258, 239, 0, False), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (134).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 258, 1)));
- Table.States (135).Action_List.Set_Capacity (36);
- Add_Action (Table.States (135), 10, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 20, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 21, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 22, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 23, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 33, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 35, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 37, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 38, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 40, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 42, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 43, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 53, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 55, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 68, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 74, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 75, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 77, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 78, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 79, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 82, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 83, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 85, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 86, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 87, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 88, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 89, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 91, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 92, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 94, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 95, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 96, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 97, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 98, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 99, Reduce, (197, 1), 1, null,
null);
- Add_Action (Table.States (135), 100, 279);
- Table.States (135).Kernel := To_Vector (((197, 258, 2, False),
(197, 258, 0, False)));
- Table.States (135).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 197, 1)));
- Table.States (136).Action_List.Set_Capacity (17);
- Add_Action (Table.States (136), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 79, 83, 87, 96), (287,
- 4), 1, null, null);
- Table.States (136).Kernel := To_Vector ((0 => (287, 275, 0,
True)));
- Table.States (136).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 287, 1)));
- Table.States (136).Minimal_Complete_Actions_Recursive := True;
+ Table.States (132).Kernel := To_Vector ((0 => (193, 192, 0,
True)));
+ Table.States (132).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 1)));
+ Table.States (132).Minimal_Complete_Actions_Recursive := True;
+ Table.States (133).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (133), 35, 279);
+ Table.States (133).Kernel := To_Vector ((0 => (140, 193, 6,
False)));
+ Table.States (133).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 279)));
+ Table.States (134).Action_List.Set_Capacity (35);
+ Add_Action (Table.States (134), (10, 20, 21, 22, 23, 33, 35, 37,
38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
+ 78, 80, 83, 84, 86, 87, 88, 89, 90, 92, 93, 95, 96, 97, 98, 99,
100), (321, 1), 1, null, null);
+ Table.States (134).Kernel := To_Vector ((0 => (321, 198, 0,
False)));
+ Table.States (134).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 321, 1)));
+ Table.States (135).Action_List.Set_Capacity (40);
+ Add_Action (Table.States (135), 10, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 20, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 21, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 22, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 23, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 33, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 35, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 37, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 38, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 40, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 42, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 43, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 53, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 55, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 68, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 74, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 75, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 76, 236);
+ Add_Action (Table.States (135), 77, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 78, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 80, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 83, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 84, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 85, 238);
+ Add_Action (Table.States (135), 86, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 87, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 88, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 89, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 90, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 92, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 93, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 95, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 96, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 97, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 98, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 99, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 100, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 101, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (135), 102, 240);
+ Add_Action (Table.States (135), 103, 241);
+ Table.States (135).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (135), 116, 242);
+ Add_Goto (Table.States (135), 323, 243);
+ Table.States (135).Kernel := To_Vector (((129, 240, 2, True),
(240, 240, 5, True), (240, 240, 2, True),
+ (259, 240, 0, False), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (135).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 259, 1)));
+ Table.States (136).Action_List.Set_Capacity (36);
+ Add_Action (Table.States (136), 10, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 20, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 21, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 22, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 23, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 33, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 35, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 37, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 38, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 40, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 42, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 43, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 53, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 55, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 68, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 74, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 75, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 77, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 78, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 80, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 83, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 84, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 86, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 87, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 88, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 89, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 90, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 92, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 93, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 95, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 96, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 97, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 98, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 99, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 100, Reduce, (198, 1), 1, null,
null);
+ Add_Action (Table.States (136), 101, 280);
+ Table.States (136).Kernel := To_Vector (((198, 259, 2, False),
(198, 259, 0, False)));
+ Table.States (136).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 198, 1)));
Table.States (137).Action_List.Set_Capacity (17);
- Add_Action (Table.States (137), 10, 280);
- Add_Conflict (Table.States (137), 10, (191, 1), 1, null, null);
- Add_Action (Table.States (137), 20, Reduce, (191, 1), 1, null,
null);
- Add_Action (Table.States (137), 21, Reduce, (191, 1), 1, null,
null);
- Add_Action (Table.States (137), 22, Reduce, (191, 1), 1, null,
null);
- Add_Action (Table.States (137), 23, Reduce, (191, 1), 1, null,
null);
- Add_Action (Table.States (137), 35, Reduce, (191, 1), 1, null,
null);
- Add_Action (Table.States (137), 37, Reduce, (191, 1), 1, null,
null);
- Add_Action (Table.States (137), 43, Reduce, (191, 1), 1, null,
null);
- Add_Action (Table.States (137), 53, Reduce, (191, 1), 1, null,
null);
- Add_Action (Table.States (137), 68, Reduce, (191, 1), 1, null,
null);
- Add_Action (Table.States (137), 74, Reduce, (191, 1), 1, null,
null);
- Add_Action (Table.States (137), 75, Reduce, (191, 1), 1, null,
null);
- Add_Action (Table.States (137), 77, Reduce, (191, 1), 1, null,
null);
- Add_Action (Table.States (137), 79, Reduce, (191, 1), 1, null,
null);
- Add_Action (Table.States (137), 83, Reduce, (191, 1), 1, null,
null);
- Add_Action (Table.States (137), 87, Reduce, (191, 1), 1, null,
null);
- Add_Action (Table.States (137), 96, Reduce, (191, 1), 1, null,
null);
- Table.States (137).Kernel := To_Vector (((191, 282, 0, True),
(282, 282, 2, True)));
- Table.States (137).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 191, 1)));
+ Add_Action (Table.States (137), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 80, 84, 88, 97), (288,
+ 4), 1, null, null);
+ Table.States (137).Kernel := To_Vector ((0 => (288, 276, 0,
True)));
+ Table.States (137).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 288, 1)));
Table.States (137).Minimal_Complete_Actions_Recursive := True;
Table.States (138).Action_List.Set_Capacity (17);
Add_Action (Table.States (138), 10, 281);
- Add_Conflict (Table.States (138), 10, (191, 2), 1, null, null);
- Add_Action (Table.States (138), 20, Reduce, (191, 2), 1, null,
null);
- Add_Action (Table.States (138), 21, Reduce, (191, 2), 1, null,
null);
- Add_Action (Table.States (138), 22, Reduce, (191, 2), 1, null,
null);
- Add_Action (Table.States (138), 23, Reduce, (191, 2), 1, null,
null);
- Add_Action (Table.States (138), 35, Reduce, (191, 2), 1, null,
null);
- Add_Action (Table.States (138), 37, Reduce, (191, 2), 1, null,
null);
- Add_Action (Table.States (138), 43, Reduce, (191, 2), 1, null,
null);
- Add_Action (Table.States (138), 53, Reduce, (191, 2), 1, null,
null);
- Add_Action (Table.States (138), 68, Reduce, (191, 2), 1, null,
null);
- Add_Action (Table.States (138), 74, Reduce, (191, 2), 1, null,
null);
- Add_Action (Table.States (138), 75, Reduce, (191, 2), 1, null,
null);
- Add_Action (Table.States (138), 77, Reduce, (191, 2), 1, null,
null);
- Add_Action (Table.States (138), 79, Reduce, (191, 2), 1, null,
null);
- Add_Action (Table.States (138), 83, Reduce, (191, 2), 1, null,
null);
- Add_Action (Table.States (138), 87, Reduce, (191, 2), 1, null,
null);
- Add_Action (Table.States (138), 96, Reduce, (191, 2), 1, null,
null);
- Table.States (138).Kernel := To_Vector (((191, 283, 0, True),
(283, 283, 3, True)));
- Table.States (138).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 191, 1)));
+ Add_Conflict (Table.States (138), 10, (192, 1), 1, null, null);
+ Add_Action (Table.States (138), 20, Reduce, (192, 1), 1, null,
null);
+ Add_Action (Table.States (138), 21, Reduce, (192, 1), 1, null,
null);
+ Add_Action (Table.States (138), 22, Reduce, (192, 1), 1, null,
null);
+ Add_Action (Table.States (138), 23, Reduce, (192, 1), 1, null,
null);
+ Add_Action (Table.States (138), 35, Reduce, (192, 1), 1, null,
null);
+ Add_Action (Table.States (138), 37, Reduce, (192, 1), 1, null,
null);
+ Add_Action (Table.States (138), 43, Reduce, (192, 1), 1, null,
null);
+ Add_Action (Table.States (138), 53, Reduce, (192, 1), 1, null,
null);
+ Add_Action (Table.States (138), 68, Reduce, (192, 1), 1, null,
null);
+ Add_Action (Table.States (138), 74, Reduce, (192, 1), 1, null,
null);
+ Add_Action (Table.States (138), 75, Reduce, (192, 1), 1, null,
null);
+ Add_Action (Table.States (138), 77, Reduce, (192, 1), 1, null,
null);
+ Add_Action (Table.States (138), 80, Reduce, (192, 1), 1, null,
null);
+ Add_Action (Table.States (138), 84, Reduce, (192, 1), 1, null,
null);
+ Add_Action (Table.States (138), 88, Reduce, (192, 1), 1, null,
null);
+ Add_Action (Table.States (138), 97, Reduce, (192, 1), 1, null,
null);
+ Table.States (138).Kernel := To_Vector (((192, 283, 0, True),
(283, 283, 2, True)));
+ Table.States (138).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 1)));
Table.States (138).Minimal_Complete_Actions_Recursive := True;
Table.States (139).Action_List.Set_Capacity (17);
- Add_Action (Table.States (139), 10, Reduce, (191, 3), 1, null,
null);
- Add_Action (Table.States (139), 20, Reduce, (191, 3), 1, null,
null);
- Add_Action (Table.States (139), 21, Reduce, (191, 3), 1, null,
null);
- Add_Action (Table.States (139), 22, Reduce, (191, 3), 1, null,
null);
- Add_Action (Table.States (139), 23, Reduce, (191, 3), 1, null,
null);
- Add_Action (Table.States (139), 35, Reduce, (191, 3), 1, null,
null);
- Add_Action (Table.States (139), 37, Reduce, (191, 3), 1, null,
null);
- Add_Action (Table.States (139), 43, 282);
- Add_Conflict (Table.States (139), 43, (191, 3), 1, null, null);
- Add_Action (Table.States (139), 53, Reduce, (191, 3), 1, null,
null);
- Add_Action (Table.States (139), 68, Reduce, (191, 3), 1, null,
null);
- Add_Action (Table.States (139), 74, Reduce, (191, 3), 1, null,
null);
- Add_Action (Table.States (139), 75, Reduce, (191, 3), 1, null,
null);
- Add_Action (Table.States (139), 77, Reduce, (191, 3), 1, null,
null);
- Add_Action (Table.States (139), 79, Reduce, (191, 3), 1, null,
null);
- Add_Action (Table.States (139), 83, Reduce, (191, 3), 1, null,
null);
- Add_Action (Table.States (139), 87, Reduce, (191, 3), 1, null,
null);
- Add_Action (Table.States (139), 96, Reduce, (191, 3), 1, null,
null);
- Table.States (139).Kernel := To_Vector (((191, 284, 0, True),
(284, 284, 2, True)));
- Table.States (139).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 191, 1)));
+ Add_Action (Table.States (139), 10, 282);
+ Add_Conflict (Table.States (139), 10, (192, 2), 1, null, null);
+ Add_Action (Table.States (139), 20, Reduce, (192, 2), 1, null,
null);
+ Add_Action (Table.States (139), 21, Reduce, (192, 2), 1, null,
null);
+ Add_Action (Table.States (139), 22, Reduce, (192, 2), 1, null,
null);
+ Add_Action (Table.States (139), 23, Reduce, (192, 2), 1, null,
null);
+ Add_Action (Table.States (139), 35, Reduce, (192, 2), 1, null,
null);
+ Add_Action (Table.States (139), 37, Reduce, (192, 2), 1, null,
null);
+ Add_Action (Table.States (139), 43, Reduce, (192, 2), 1, null,
null);
+ Add_Action (Table.States (139), 53, Reduce, (192, 2), 1, null,
null);
+ Add_Action (Table.States (139), 68, Reduce, (192, 2), 1, null,
null);
+ Add_Action (Table.States (139), 74, Reduce, (192, 2), 1, null,
null);
+ Add_Action (Table.States (139), 75, Reduce, (192, 2), 1, null,
null);
+ Add_Action (Table.States (139), 77, Reduce, (192, 2), 1, null,
null);
+ Add_Action (Table.States (139), 80, Reduce, (192, 2), 1, null,
null);
+ Add_Action (Table.States (139), 84, Reduce, (192, 2), 1, null,
null);
+ Add_Action (Table.States (139), 88, Reduce, (192, 2), 1, null,
null);
+ Add_Action (Table.States (139), 97, Reduce, (192, 2), 1, null,
null);
+ Table.States (139).Kernel := To_Vector (((192, 284, 0, True),
(284, 284, 3, True)));
+ Table.States (139).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 1)));
Table.States (139).Minimal_Complete_Actions_Recursive := True;
end Subr_2;
procedure Subr_3
is begin
Table.States (140).Action_List.Set_Capacity (17);
- Add_Action (Table.States (140), 10, Reduce, (191, 4), 1, null,
null);
- Add_Action (Table.States (140), 20, Reduce, (191, 4), 1, null,
null);
- Add_Action (Table.States (140), 21, Reduce, (191, 4), 1, null,
null);
- Add_Action (Table.States (140), 22, Reduce, (191, 4), 1, null,
null);
- Add_Action (Table.States (140), 23, Reduce, (191, 4), 1, null,
null);
- Add_Action (Table.States (140), 35, Reduce, (191, 4), 1, null,
null);
- Add_Action (Table.States (140), 37, Reduce, (191, 4), 1, null,
null);
+ Add_Action (Table.States (140), 10, Reduce, (192, 3), 1, null,
null);
+ Add_Action (Table.States (140), 20, Reduce, (192, 3), 1, null,
null);
+ Add_Action (Table.States (140), 21, Reduce, (192, 3), 1, null,
null);
+ Add_Action (Table.States (140), 22, Reduce, (192, 3), 1, null,
null);
+ Add_Action (Table.States (140), 23, Reduce, (192, 3), 1, null,
null);
+ Add_Action (Table.States (140), 35, Reduce, (192, 3), 1, null,
null);
+ Add_Action (Table.States (140), 37, Reduce, (192, 3), 1, null,
null);
Add_Action (Table.States (140), 43, 283);
- Add_Conflict (Table.States (140), 43, (191, 4), 1, null, null);
- Add_Action (Table.States (140), 53, Reduce, (191, 4), 1, null,
null);
- Add_Action (Table.States (140), 68, Reduce, (191, 4), 1, null,
null);
- Add_Action (Table.States (140), 74, Reduce, (191, 4), 1, null,
null);
- Add_Action (Table.States (140), 75, Reduce, (191, 4), 1, null,
null);
- Add_Action (Table.States (140), 77, Reduce, (191, 4), 1, null,
null);
- Add_Action (Table.States (140), 79, Reduce, (191, 4), 1, null,
null);
- Add_Action (Table.States (140), 83, Reduce, (191, 4), 1, null,
null);
- Add_Action (Table.States (140), 87, Reduce, (191, 4), 1, null,
null);
- Add_Action (Table.States (140), 96, Reduce, (191, 4), 1, null,
null);
- Table.States (140).Kernel := To_Vector (((191, 285, 0, True),
(285, 285, 3, True)));
- Table.States (140).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 191, 1)));
+ Add_Conflict (Table.States (140), 43, (192, 3), 1, null, null);
+ Add_Action (Table.States (140), 53, Reduce, (192, 3), 1, null,
null);
+ Add_Action (Table.States (140), 68, Reduce, (192, 3), 1, null,
null);
+ Add_Action (Table.States (140), 74, Reduce, (192, 3), 1, null,
null);
+ Add_Action (Table.States (140), 75, Reduce, (192, 3), 1, null,
null);
+ Add_Action (Table.States (140), 77, Reduce, (192, 3), 1, null,
null);
+ Add_Action (Table.States (140), 80, Reduce, (192, 3), 1, null,
null);
+ Add_Action (Table.States (140), 84, Reduce, (192, 3), 1, null,
null);
+ Add_Action (Table.States (140), 88, Reduce, (192, 3), 1, null,
null);
+ Add_Action (Table.States (140), 97, Reduce, (192, 3), 1, null,
null);
+ Table.States (140).Kernel := To_Vector (((192, 285, 0, True),
(285, 285, 2, True)));
+ Table.States (140).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 1)));
Table.States (140).Minimal_Complete_Actions_Recursive := True;
Table.States (141).Action_List.Set_Capacity (17);
- Add_Action (Table.States (141), 10, Reduce, (191, 5), 1, null,
null);
- Add_Action (Table.States (141), 20, Reduce, (191, 5), 1, null,
null);
- Add_Action (Table.States (141), 21, Reduce, (191, 5), 1, null,
null);
- Add_Action (Table.States (141), 22, Reduce, (191, 5), 1, null,
null);
- Add_Action (Table.States (141), 23, Reduce, (191, 5), 1, null,
null);
- Add_Action (Table.States (141), 35, Reduce, (191, 5), 1, null,
null);
- Add_Action (Table.States (141), 37, Reduce, (191, 5), 1, null,
null);
- Add_Action (Table.States (141), 43, Reduce, (191, 5), 1, null,
null);
- Add_Action (Table.States (141), 53, Reduce, (191, 5), 1, null,
null);
- Add_Action (Table.States (141), 68, Reduce, (191, 5), 1, null,
null);
- Add_Action (Table.States (141), 74, Reduce, (191, 5), 1, null,
null);
- Add_Action (Table.States (141), 75, 284);
- Add_Conflict (Table.States (141), 75, (191, 5), 1, null, null);
- Add_Action (Table.States (141), 77, Reduce, (191, 5), 1, null,
null);
- Add_Action (Table.States (141), 79, Reduce, (191, 5), 1, null,
null);
- Add_Action (Table.States (141), 83, Reduce, (191, 5), 1, null,
null);
- Add_Action (Table.States (141), 87, Reduce, (191, 5), 1, null,
null);
- Add_Action (Table.States (141), 96, Reduce, (191, 5), 1, null,
null);
- Table.States (141).Kernel := To_Vector (((191, 286, 0, True),
(286, 286, 2, True)));
- Table.States (141).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 191, 1)));
+ Add_Action (Table.States (141), 10, Reduce, (192, 4), 1, null,
null);
+ Add_Action (Table.States (141), 20, Reduce, (192, 4), 1, null,
null);
+ Add_Action (Table.States (141), 21, Reduce, (192, 4), 1, null,
null);
+ Add_Action (Table.States (141), 22, Reduce, (192, 4), 1, null,
null);
+ Add_Action (Table.States (141), 23, Reduce, (192, 4), 1, null,
null);
+ Add_Action (Table.States (141), 35, Reduce, (192, 4), 1, null,
null);
+ Add_Action (Table.States (141), 37, Reduce, (192, 4), 1, null,
null);
+ Add_Action (Table.States (141), 43, 284);
+ Add_Conflict (Table.States (141), 43, (192, 4), 1, null, null);
+ Add_Action (Table.States (141), 53, Reduce, (192, 4), 1, null,
null);
+ Add_Action (Table.States (141), 68, Reduce, (192, 4), 1, null,
null);
+ Add_Action (Table.States (141), 74, Reduce, (192, 4), 1, null,
null);
+ Add_Action (Table.States (141), 75, Reduce, (192, 4), 1, null,
null);
+ Add_Action (Table.States (141), 77, Reduce, (192, 4), 1, null,
null);
+ Add_Action (Table.States (141), 80, Reduce, (192, 4), 1, null,
null);
+ Add_Action (Table.States (141), 84, Reduce, (192, 4), 1, null,
null);
+ Add_Action (Table.States (141), 88, Reduce, (192, 4), 1, null,
null);
+ Add_Action (Table.States (141), 97, Reduce, (192, 4), 1, null,
null);
+ Table.States (141).Kernel := To_Vector (((192, 286, 0, True),
(286, 286, 3, True)));
+ Table.States (141).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 1)));
Table.States (141).Minimal_Complete_Actions_Recursive := True;
Table.States (142).Action_List.Set_Capacity (17);
- Add_Action (Table.States (142), 10, 285);
- Add_Conflict (Table.States (142), 10, (191, 0), 1, null, null);
- Add_Action (Table.States (142), 20, Reduce, (191, 0), 1, null,
null);
- Add_Action (Table.States (142), 21, Reduce, (191, 0), 1, null,
null);
- Add_Action (Table.States (142), 22, Reduce, (191, 0), 1, null,
null);
- Add_Action (Table.States (142), 23, Reduce, (191, 0), 1, null,
null);
- Add_Action (Table.States (142), 35, Reduce, (191, 0), 1, null,
null);
- Add_Action (Table.States (142), 37, Reduce, (191, 0), 1, null,
null);
- Add_Action (Table.States (142), 43, 286);
- Add_Conflict (Table.States (142), 43, (191, 0), 1, null, null);
- Add_Action (Table.States (142), 53, Reduce, (191, 0), 1, null,
null);
- Add_Action (Table.States (142), 68, Reduce, (191, 0), 1, null,
null);
- Add_Action (Table.States (142), 74, Reduce, (191, 0), 1, null,
null);
- Add_Action (Table.States (142), 75, 287);
- Add_Conflict (Table.States (142), 75, (191, 0), 1, null, null);
- Add_Action (Table.States (142), 77, Reduce, (191, 0), 1, null,
null);
- Add_Action (Table.States (142), 79, Reduce, (191, 0), 1, null,
null);
- Add_Action (Table.States (142), 83, Reduce, (191, 0), 1, null,
null);
- Add_Action (Table.States (142), 87, Reduce, (191, 0), 1, null,
null);
- Add_Action (Table.States (142), 96, Reduce, (191, 0), 1, null,
null);
- Table.States (142).Kernel := To_Vector (((191, 287, 0, True),
(282, 287, 2, True), (283, 287, 3, True),
- (284, 287, 2, True), (285, 287, 3, True), (286, 287, 2, True)));
- Table.States (142).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 191, 1)));
+ Add_Action (Table.States (142), 10, Reduce, (192, 5), 1, null,
null);
+ Add_Action (Table.States (142), 20, Reduce, (192, 5), 1, null,
null);
+ Add_Action (Table.States (142), 21, Reduce, (192, 5), 1, null,
null);
+ Add_Action (Table.States (142), 22, Reduce, (192, 5), 1, null,
null);
+ Add_Action (Table.States (142), 23, Reduce, (192, 5), 1, null,
null);
+ Add_Action (Table.States (142), 35, Reduce, (192, 5), 1, null,
null);
+ Add_Action (Table.States (142), 37, Reduce, (192, 5), 1, null,
null);
+ Add_Action (Table.States (142), 43, Reduce, (192, 5), 1, null,
null);
+ Add_Action (Table.States (142), 53, Reduce, (192, 5), 1, null,
null);
+ Add_Action (Table.States (142), 68, Reduce, (192, 5), 1, null,
null);
+ Add_Action (Table.States (142), 74, Reduce, (192, 5), 1, null,
null);
+ Add_Action (Table.States (142), 75, 285);
+ Add_Conflict (Table.States (142), 75, (192, 5), 1, null, null);
+ Add_Action (Table.States (142), 77, Reduce, (192, 5), 1, null,
null);
+ Add_Action (Table.States (142), 80, Reduce, (192, 5), 1, null,
null);
+ Add_Action (Table.States (142), 84, Reduce, (192, 5), 1, null,
null);
+ Add_Action (Table.States (142), 88, Reduce, (192, 5), 1, null,
null);
+ Add_Action (Table.States (142), 97, Reduce, (192, 5), 1, null,
null);
+ Table.States (142).Kernel := To_Vector (((192, 287, 0, True),
(287, 287, 2, True)));
+ Table.States (142).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 1)));
Table.States (142).Minimal_Complete_Actions_Recursive := True;
- Table.States (143).Action_List.Set_Capacity (25);
- Add_Action (Table.States (143), 10, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (143), 20, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (143), 21, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (143), 22, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (143), 23, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (143), 33, 288);
- Add_Action (Table.States (143), 35, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (143), 37, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (143), 40, 289);
- Add_Action (Table.States (143), 43, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (143), 53, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (143), 68, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (143), 74, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (143), 75, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (143), 77, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (143), 79, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (143), 83, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (143), 86, 290);
- Add_Action (Table.States (143), 87, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (143), 88, 291);
- Add_Action (Table.States (143), 89, 292);
- Add_Action (Table.States (143), 91, 293);
- Add_Action (Table.States (143), 92, 294);
- Add_Action (Table.States (143), 96, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (143), 98, 295);
- Table.States (143).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (143), 288, 296);
- Table.States (143).Kernel := To_Vector (((287, 301, 3, False),
(287, 301, 2, False), (287, 301, 2, False),
- (287, 301, 0, False)));
- Table.States (143).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 287, 1)));
- Table.States (144).Action_List.Set_Capacity (35);
- Add_Action (Table.States (144), 10, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 20, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 21, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 22, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 23, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 33, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 35, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 37, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 38, 297);
- Add_Action (Table.States (144), 40, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 42, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 43, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 53, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 55, 298);
- Add_Action (Table.States (144), 68, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 74, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 75, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 77, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 78, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 79, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 82, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 83, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 85, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 86, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 87, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 88, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 89, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 91, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 92, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 94, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 95, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 96, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 97, 299);
- Add_Action (Table.States (144), 98, Reduce, (321, 1), 1, null,
null);
- Add_Action (Table.States (144), 99, 300);
+ Table.States (143).Action_List.Set_Capacity (17);
+ Add_Action (Table.States (143), 10, 286);
+ Add_Conflict (Table.States (143), 10, (192, 0), 1, null, null);
+ Add_Action (Table.States (143), 20, Reduce, (192, 0), 1, null,
null);
+ Add_Action (Table.States (143), 21, Reduce, (192, 0), 1, null,
null);
+ Add_Action (Table.States (143), 22, Reduce, (192, 0), 1, null,
null);
+ Add_Action (Table.States (143), 23, Reduce, (192, 0), 1, null,
null);
+ Add_Action (Table.States (143), 35, Reduce, (192, 0), 1, null,
null);
+ Add_Action (Table.States (143), 37, Reduce, (192, 0), 1, null,
null);
+ Add_Action (Table.States (143), 43, 287);
+ Add_Conflict (Table.States (143), 43, (192, 0), 1, null, null);
+ Add_Action (Table.States (143), 53, Reduce, (192, 0), 1, null,
null);
+ Add_Action (Table.States (143), 68, Reduce, (192, 0), 1, null,
null);
+ Add_Action (Table.States (143), 74, Reduce, (192, 0), 1, null,
null);
+ Add_Action (Table.States (143), 75, 288);
+ Add_Conflict (Table.States (143), 75, (192, 0), 1, null, null);
+ Add_Action (Table.States (143), 77, Reduce, (192, 0), 1, null,
null);
+ Add_Action (Table.States (143), 80, Reduce, (192, 0), 1, null,
null);
+ Add_Action (Table.States (143), 84, Reduce, (192, 0), 1, null,
null);
+ Add_Action (Table.States (143), 88, Reduce, (192, 0), 1, null,
null);
+ Add_Action (Table.States (143), 97, Reduce, (192, 0), 1, null,
null);
+ Table.States (143).Kernel := To_Vector (((192, 288, 0, True),
(283, 288, 2, True), (284, 288, 3, True),
+ (285, 288, 2, True), (286, 288, 3, True), (287, 288, 2, True)));
+ Table.States (143).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 1)));
+ Table.States (143).Minimal_Complete_Actions_Recursive := True;
+ Table.States (144).Action_List.Set_Capacity (25);
+ Add_Action (Table.States (144), 10, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (144), 20, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (144), 21, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (144), 22, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (144), 23, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (144), 33, 289);
+ Add_Action (Table.States (144), 35, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (144), 37, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (144), 40, 290);
+ Add_Action (Table.States (144), 43, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (144), 53, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (144), 68, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (144), 74, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (144), 75, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (144), 77, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (144), 80, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (144), 84, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (144), 87, 291);
+ Add_Action (Table.States (144), 88, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (144), 89, 292);
+ Add_Action (Table.States (144), 90, 293);
+ Add_Action (Table.States (144), 92, 294);
+ Add_Action (Table.States (144), 93, 295);
+ Add_Action (Table.States (144), 97, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (144), 99, 296);
Table.States (144).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (144), 237, 301);
- Table.States (144).Kernel := To_Vector (((320, 320, 2, True),
(321, 320, 0, False)));
- Table.States (144).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 321, 1)));
- Table.States (145).Action_List.Set_Capacity (31);
- Add_Action (Table.States (145), 10, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 20, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 21, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 22, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 23, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 33, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 35, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 37, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 40, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 42, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 43, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 53, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 68, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 74, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 75, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 77, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 78, 302);
- Add_Action (Table.States (145), 79, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 82, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 83, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 85, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 86, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 87, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 88, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 89, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 91, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 92, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 94, 303);
- Add_Action (Table.States (145), 95, 304);
- Add_Action (Table.States (145), 96, Reduce, (301, 1), 1, null,
null);
- Add_Action (Table.States (145), 98, Reduce, (301, 1), 1, null,
null);
+ Add_Goto (Table.States (144), 289, 297);
+ Table.States (144).Kernel := To_Vector (((288, 302, 3, False),
(288, 302, 2, False), (288, 302, 2, False),
+ (288, 302, 0, False)));
+ Table.States (144).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 288, 1)));
+ Table.States (145).Action_List.Set_Capacity (35);
+ Add_Action (Table.States (145), 10, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 20, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 21, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 22, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 23, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 33, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 35, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 37, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 38, 298);
+ Add_Action (Table.States (145), 40, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 42, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 43, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 53, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 55, 299);
+ Add_Action (Table.States (145), 68, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 74, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 75, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 77, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 78, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 80, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 83, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 84, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 86, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 87, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 88, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 89, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 90, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 92, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 93, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 95, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 96, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 97, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 98, 300);
+ Add_Action (Table.States (145), 99, Reduce, (322, 1), 1, null,
null);
+ Add_Action (Table.States (145), 100, 301);
Table.States (145).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (145), 130, 305);
- Table.States (145).Kernel := To_Vector (((301, 321, 0, False),
(321, 321, 2, True)));
- Table.States (145).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 301, 1)));
- Table.States (146).Action_List.Set_Capacity (9);
- Add_Action (Table.States (146), 3, 121);
- Add_Action (Table.States (146), 39, 122);
- Add_Action (Table.States (146), 40, 123);
- Add_Action (Table.States (146), 41, 124);
- Add_Action (Table.States (146), 76, 126);
- Add_Action (Table.States (146), 103, 129);
- Add_Action (Table.States (146), 104, 119);
- Add_Action (Table.States (146), 105, 33);
- Add_Action (Table.States (146), 106, 34);
- Table.States (146).Goto_List.Set_Capacity (9);
- Add_Goto (Table.States (146), 117, 130);
- Add_Goto (Table.States (146), 128, 41);
- Add_Goto (Table.States (146), 197, 133);
- Add_Goto (Table.States (146), 239, 134);
- Add_Goto (Table.States (146), 258, 135);
- Add_Goto (Table.States (146), 272, 92);
- Add_Goto (Table.States (146), 293, 97);
- Add_Goto (Table.States (146), 320, 144);
- Add_Goto (Table.States (146), 321, 306);
- Table.States (146).Kernel := To_Vector ((0 => (301, 330, 1,
False)));
- Table.States (146).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
- Table.States (147).Action_List.Set_Capacity (13);
- Add_Action (Table.States (147), 3, 121);
- Add_Action (Table.States (147), 39, 122);
- Add_Action (Table.States (147), 40, 123);
- Add_Action (Table.States (147), 41, 124);
- Add_Action (Table.States (147), 52, 125);
- Add_Action (Table.States (147), 76, 126);
- Add_Action (Table.States (147), 94, 127);
- Add_Action (Table.States (147), 95, 128);
- Add_Action (Table.States (147), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (147), 103, 129);
- Add_Action (Table.States (147), 104, 119);
- Add_Action (Table.States (147), 105, 33);
+ Add_Goto (Table.States (145), 238, 302);
+ Table.States (145).Kernel := To_Vector (((321, 321, 2, True),
(322, 321, 0, False)));
+ Table.States (145).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 322, 1)));
+ Table.States (146).Action_List.Set_Capacity (31);
+ Add_Action (Table.States (146), 10, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 20, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 21, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 22, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 23, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 33, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 35, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 37, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 40, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 42, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 43, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 53, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 68, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 74, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 75, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 77, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 78, 303);
+ Add_Action (Table.States (146), 80, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 83, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 84, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 86, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 87, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 88, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 89, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 90, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 92, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 93, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 95, 304);
+ Add_Action (Table.States (146), 96, 305);
+ Add_Action (Table.States (146), 97, Reduce, (302, 1), 1, null,
null);
+ Add_Action (Table.States (146), 99, Reduce, (302, 1), 1, null,
null);
+ Table.States (146).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (146), 131, 306);
+ Table.States (146).Kernel := To_Vector (((302, 322, 0, False),
(322, 322, 2, True)));
+ Table.States (146).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 302, 1)));
+ Table.States (147).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (147), 3, 122);
+ Add_Action (Table.States (147), 39, 123);
+ Add_Action (Table.States (147), 40, 124);
+ Add_Action (Table.States (147), 41, 125);
+ Add_Action (Table.States (147), 76, 127);
+ Add_Action (Table.States (147), 79, 31);
+ Add_Action (Table.States (147), 104, 130);
+ Add_Action (Table.States (147), 105, 120);
Add_Action (Table.States (147), 106, 34);
- Table.States (147).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (147), 117, 130);
- Add_Goto (Table.States (147), 128, 41);
- Add_Goto (Table.States (147), 191, 131);
- Add_Goto (Table.States (147), 192, 307);
- Add_Goto (Table.States (147), 197, 133);
- Add_Goto (Table.States (147), 239, 134);
- Add_Goto (Table.States (147), 258, 135);
- Add_Goto (Table.States (147), 272, 92);
- Add_Goto (Table.States (147), 275, 136);
- Add_Goto (Table.States (147), 282, 137);
- Add_Goto (Table.States (147), 283, 138);
- Add_Goto (Table.States (147), 284, 139);
- Add_Goto (Table.States (147), 285, 140);
- Add_Goto (Table.States (147), 286, 141);
- Add_Goto (Table.States (147), 287, 142);
- Add_Goto (Table.States (147), 293, 97);
- Add_Goto (Table.States (147), 301, 143);
- Add_Goto (Table.States (147), 320, 144);
+ Add_Action (Table.States (147), 107, 35);
+ Table.States (147).Goto_List.Set_Capacity (9);
+ Add_Goto (Table.States (147), 118, 131);
+ Add_Goto (Table.States (147), 129, 42);
+ Add_Goto (Table.States (147), 198, 134);
+ Add_Goto (Table.States (147), 240, 135);
+ Add_Goto (Table.States (147), 259, 136);
+ Add_Goto (Table.States (147), 273, 93);
+ Add_Goto (Table.States (147), 294, 98);
Add_Goto (Table.States (147), 321, 145);
- Add_Goto (Table.States (147), 330, 146);
- Table.States (147).Kernel := To_Vector ((0 => (161, 70, 1,
False)));
- Table.States (147).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (148).Action_List.Set_Capacity (1);
- Add_Action (Table.States (148), 96, 308);
- Table.States (148).Kernel := To_Vector ((0 => (161, 192, 1,
False)));
- Table.States (148).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 308)));
- Table.States (149).Action_List.Set_Capacity (2);
- Add_Action (Table.States (149), (72, 96), (220, 0), 1, null,
identifier_opt_0_check'Access);
- Table.States (149).Kernel := To_Vector ((0 => (220, 104, 0,
False)));
- Table.States (149).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 220, 1)));
+ Add_Goto (Table.States (147), 322, 307);
+ Table.States (147).Kernel := To_Vector ((0 => (302, 331, 1,
False)));
+ Table.States (147).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
+ Table.States (148).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (148), 3, 122);
+ Add_Action (Table.States (148), 39, 123);
+ Add_Action (Table.States (148), 40, 124);
+ Add_Action (Table.States (148), 41, 125);
+ Add_Action (Table.States (148), 52, 126);
+ Add_Action (Table.States (148), 76, 127);
+ Add_Action (Table.States (148), 79, 31);
+ Add_Action (Table.States (148), 95, 128);
+ Add_Action (Table.States (148), 96, 129);
+ Add_Action (Table.States (148), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (148), 104, 130);
+ Add_Action (Table.States (148), 105, 120);
+ Add_Action (Table.States (148), 106, 34);
+ Add_Action (Table.States (148), 107, 35);
+ Table.States (148).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (148), 118, 131);
+ Add_Goto (Table.States (148), 129, 42);
+ Add_Goto (Table.States (148), 192, 132);
+ Add_Goto (Table.States (148), 193, 308);
+ Add_Goto (Table.States (148), 198, 134);
+ Add_Goto (Table.States (148), 240, 135);
+ Add_Goto (Table.States (148), 259, 136);
+ Add_Goto (Table.States (148), 273, 93);
+ Add_Goto (Table.States (148), 276, 137);
+ Add_Goto (Table.States (148), 283, 138);
+ Add_Goto (Table.States (148), 284, 139);
+ Add_Goto (Table.States (148), 285, 140);
+ Add_Goto (Table.States (148), 286, 141);
+ Add_Goto (Table.States (148), 287, 142);
+ Add_Goto (Table.States (148), 288, 143);
+ Add_Goto (Table.States (148), 294, 98);
+ Add_Goto (Table.States (148), 302, 144);
+ Add_Goto (Table.States (148), 321, 145);
+ Add_Goto (Table.States (148), 322, 146);
+ Add_Goto (Table.States (148), 331, 147);
+ Table.States (148).Kernel := To_Vector ((0 => (162, 70, 1,
False)));
+ Table.States (148).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (149).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (149), 97, 309);
+ Table.States (149).Kernel := To_Vector ((0 => (162, 193, 1,
False)));
+ Table.States (149).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 309)));
Table.States (150).Action_List.Set_Capacity (2);
- Add_Action (Table.States (150), 72, 309);
- Add_Action (Table.States (150), 96, 310);
- Table.States (150).Kernel := To_Vector (((190, 220, 2, False),
(190, 220, 1, False)));
- Table.States (150).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 310)));
- Table.States (151).Action_List.Set_Capacity (8);
- Add_Action (Table.States (151), 33, 311);
- Add_Action (Table.States (151), 42, 312);
- Add_Action (Table.States (151), 71, Reduce, (163, 0), 1, null,
null);
- Add_Conflict (Table.States (151), 71, (239, 5), 1, name_5'Access,
name_5_check'Access);
- Add_Action (Table.States (151), 76, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (151), 81, 313);
- Add_Action (Table.States (151), 84, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (151), 101, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (151), 102, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Table.States (151).Kernel := To_Vector (((163, 104, 0, False),
(230, 104, 5, False), (230, 104, 4, False),
- (230, 104, 3, False), (230, 104, 3, False), (230, 104, 2, False),
(230, 104, 2, False), (239, 104, 0,
+ Add_Action (Table.States (150), (72, 97), (221, 0), 1, null,
identifier_opt_0_check'Access);
+ Table.States (150).Kernel := To_Vector ((0 => (221, 105, 0,
False)));
+ Table.States (150).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 221, 1)));
+ Table.States (151).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (151), 72, 310);
+ Add_Action (Table.States (151), 97, 311);
+ Table.States (151).Kernel := To_Vector (((191, 221, 2, False),
(191, 221, 1, False)));
+ Table.States (151).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 311)));
+ Table.States (152).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (152), 33, 312);
+ Add_Action (Table.States (152), 42, 313);
+ Add_Action (Table.States (152), 71, Reduce, (164, 0), 1, null,
null);
+ Add_Conflict (Table.States (152), 71, (240, 5), 1, name_5'Access,
name_5_check'Access);
+ Add_Action (Table.States (152), 76, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (152), 82, 314);
+ Add_Action (Table.States (152), 85, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (152), 102, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (152), 103, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Table.States (152).Kernel := To_Vector (((164, 105, 0, False),
(231, 105, 5, False), (231, 105, 4, False),
+ (231, 105, 3, False), (231, 105, 3, False), (231, 105, 2, False),
(231, 105, 2, False), (240, 105, 0,
False)));
- Table.States (151).Minimal_Complete_Actions := To_Vector
(((Reduce, 163, 1), (Reduce, 239, 1)));
- Table.States (152).Action_List.Set_Capacity (5);
- Add_Action (Table.States (152), 71, Reduce, (163, 1), 1, null,
null);
- Add_Conflict (Table.States (152), 71, (239, 7), 1, null,
name_7_check'Access);
- Add_Action (Table.States (152), 76, Reduce, (239, 7), 1, null,
name_7_check'Access);
- Add_Action (Table.States (152), 84, Reduce, (239, 7), 1, null,
name_7_check'Access);
- Add_Action (Table.States (152), 101, Reduce, (239, 7), 1, null,
name_7_check'Access);
- Add_Action (Table.States (152), 102, Reduce, (239, 7), 1, null,
name_7_check'Access);
- Table.States (152).Kernel := To_Vector (((163, 105, 0, False),
(239, 105, 0, False)));
- Table.States (152).Minimal_Complete_Actions := To_Vector
(((Reduce, 163, 1), (Reduce, 239, 1)));
+ Table.States (152).Minimal_Complete_Actions := To_Vector
(((Reduce, 164, 1), (Reduce, 240, 1)));
Table.States (153).Action_List.Set_Capacity (5);
- Add_Action (Table.States (153), 71, 314);
- Add_Conflict (Table.States (153), 71, (239, 3), 1, null, null);
- Add_Action (Table.States (153), 76, Reduce, (239, 3), 1, null,
null);
- Add_Action (Table.States (153), 84, Reduce, (239, 3), 1, null,
null);
- Add_Action (Table.States (153), 101, Reduce, (239, 3), 1, null,
null);
- Add_Action (Table.States (153), 102, Reduce, (239, 3), 1, null,
null);
- Table.States (153).Kernel := To_Vector (((121, 128, 2, False),
(239, 128, 0, True)));
- Table.States (153).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 239, 1)));
- Table.States (153).Minimal_Complete_Actions_Recursive := True;
- Table.States (154).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (153), 71, Reduce, (164, 1), 1, null,
null);
+ Add_Conflict (Table.States (153), 71, (240, 7), 1, null,
name_7_check'Access);
+ Add_Action (Table.States (153), 76, Reduce, (240, 7), 1, null,
name_7_check'Access);
+ Add_Action (Table.States (153), 85, Reduce, (240, 7), 1, null,
name_7_check'Access);
+ Add_Action (Table.States (153), 102, Reduce, (240, 7), 1, null,
name_7_check'Access);
+ Add_Action (Table.States (153), 103, Reduce, (240, 7), 1, null,
name_7_check'Access);
+ Table.States (153).Kernel := To_Vector (((164, 106, 0, False),
(240, 106, 0, False)));
+ Table.States (153).Minimal_Complete_Actions := To_Vector
(((Reduce, 164, 1), (Reduce, 240, 1)));
+ Table.States (154).Action_List.Set_Capacity (5);
Add_Action (Table.States (154), 71, 315);
- Table.States (154).Kernel := To_Vector ((0 => (127, 163, 3,
False)));
- Table.States (154).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 71, 315)));
+ Add_Conflict (Table.States (154), 71, (240, 3), 1, null, null);
+ Add_Action (Table.States (154), 76, Reduce, (240, 3), 1, null,
null);
+ Add_Action (Table.States (154), 85, Reduce, (240, 3), 1, null,
null);
+ Add_Action (Table.States (154), 102, Reduce, (240, 3), 1, null,
null);
+ Add_Action (Table.States (154), 103, Reduce, (240, 3), 1, null,
null);
+ Table.States (154).Kernel := To_Vector (((122, 129, 2, False),
(240, 129, 0, True)));
+ Table.States (154).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 240, 1)));
+ Table.States (154).Minimal_Complete_Actions_Recursive := True;
Table.States (155).Action_List.Set_Capacity (1);
- Add_Action (Table.States (155), (1 => 37), (231, 0), 1, null,
null);
- Table.States (155).Kernel := To_Vector ((0 => (231, 230, 0,
False)));
- Table.States (155).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 231, 1)));
+ Add_Action (Table.States (155), 71, 316);
+ Table.States (155).Kernel := To_Vector ((0 => (128, 164, 3,
False)));
+ Table.States (155).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 71, 316)));
Table.States (156).Action_List.Set_Capacity (1);
- Add_Action (Table.States (156), (1 => 37), (229, 1), 2,
iteration_scheme_1'Access, null);
- Table.States (156).Kernel := To_Vector ((0 => (229, 231, 0,
False)));
- Table.States (156).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 229, 2)));
- Table.States (157).Action_List.Set_Capacity (5);
- Add_Action (Table.States (157), 71, 316);
- Add_Action (Table.States (157), 76, 235);
- Add_Action (Table.States (157), 84, 237);
- Add_Action (Table.States (157), 101, 239);
- Add_Action (Table.States (157), 102, 240);
- Table.States (157).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (157), 115, 241);
- Add_Goto (Table.States (157), 322, 242);
- Table.States (157).Kernel := To_Vector (((128, 239, 2, True),
(182, 239, 4, False), (239, 239, 5, True),
- (239, 239, 2, True), (272, 239, 3, True), (281, 239, 13, False),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True), (293, 239, 2, True)));
- Table.States (157).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 71, 316)));
+ Add_Action (Table.States (156), (1 => 37), (232, 0), 1, null,
null);
+ Table.States (156).Kernel := To_Vector ((0 => (232, 231, 0,
False)));
+ Table.States (156).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 232, 1)));
+ Table.States (157).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (157), (1 => 37), (230, 1), 2,
iteration_scheme_1'Access, null);
+ Table.States (157).Kernel := To_Vector ((0 => (230, 232, 0,
False)));
+ Table.States (157).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 230, 2)));
Table.States (158).Action_List.Set_Capacity (5);
- Add_Action (Table.States (158), 58, 317);
- Add_Action (Table.States (158), 76, 318);
- Add_Action (Table.States (158), 84, 237);
- Add_Action (Table.States (158), 101, 239);
+ Add_Action (Table.States (158), 71, 317);
+ Add_Action (Table.States (158), 76, 236);
+ Add_Action (Table.States (158), 85, 238);
Add_Action (Table.States (158), 102, 240);
- Table.States (158).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (158), 115, 241);
- Add_Goto (Table.States (158), 199, 319);
- Add_Goto (Table.States (158), 252, 320);
- Add_Goto (Table.States (158), 291, 321);
- Add_Goto (Table.States (158), 322, 242);
- Table.States (158).Kernel := To_Vector (((128, 239, 2, True),
(207, 239, 1, False), (239, 239, 5, True),
- (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (158).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 58, 317)));
- Table.States (159).Action_List.Set_Capacity (3);
- Add_Action (Table.States (159), 104, 119);
- Add_Action (Table.States (159), 105, 33);
- Add_Action (Table.States (159), 106, 34);
- Table.States (159).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (159), 128, 41);
- Add_Goto (Table.States (159), 239, 322);
- Add_Goto (Table.States (159), 272, 92);
- Add_Goto (Table.States (159), 293, 97);
- Table.States (159).Kernel := To_Vector ((0 => (215, 29, 4,
False)));
- Table.States (159).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (160).Action_List.Set_Capacity (3);
- Add_Action (Table.States (160), 104, 119);
- Add_Action (Table.States (160), 105, 33);
+ Add_Action (Table.States (158), 103, 241);
+ Table.States (158).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (158), 116, 242);
+ Add_Goto (Table.States (158), 323, 243);
+ Table.States (158).Kernel := To_Vector (((129, 240, 2, True),
(183, 240, 4, False), (240, 240, 5, True),
+ (240, 240, 2, True), (273, 240, 3, True), (282, 240, 13, False),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True), (294, 240, 2, True)));
+ Table.States (158).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 71, 317)));
+ Table.States (159).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (159), 58, 318);
+ Add_Action (Table.States (159), 76, 319);
+ Add_Action (Table.States (159), 85, 238);
+ Add_Action (Table.States (159), 102, 240);
+ Add_Action (Table.States (159), 103, 241);
+ Table.States (159).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (159), 116, 242);
+ Add_Goto (Table.States (159), 200, 320);
+ Add_Goto (Table.States (159), 253, 321);
+ Add_Goto (Table.States (159), 292, 322);
+ Add_Goto (Table.States (159), 323, 243);
+ Table.States (159).Kernel := To_Vector (((129, 240, 2, True),
(208, 240, 1, False), (240, 240, 5, True),
+ (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (159).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 58, 318)));
+ Table.States (160).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (160), 79, 31);
+ Add_Action (Table.States (160), 105, 120);
Add_Action (Table.States (160), 106, 34);
+ Add_Action (Table.States (160), 107, 35);
Table.States (160).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (160), 128, 41);
- Add_Goto (Table.States (160), 239, 323);
- Add_Goto (Table.States (160), 272, 92);
- Add_Goto (Table.States (160), 293, 97);
- Table.States (160).Kernel := To_Vector ((0 => (215, 47, 4,
False)));
- Table.States (160).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (161).Action_List.Set_Capacity (3);
- Add_Action (Table.States (161), 104, 119);
- Add_Action (Table.States (161), 105, 33);
+ Add_Goto (Table.States (160), 129, 42);
+ Add_Goto (Table.States (160), 240, 323);
+ Add_Goto (Table.States (160), 273, 93);
+ Add_Goto (Table.States (160), 294, 98);
+ Table.States (160).Kernel := To_Vector ((0 => (216, 29, 4,
False)));
+ Table.States (160).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (161).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (161), 79, 31);
+ Add_Action (Table.States (161), 105, 120);
Add_Action (Table.States (161), 106, 34);
+ Add_Action (Table.States (161), 107, 35);
Table.States (161).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (161), 128, 41);
- Add_Goto (Table.States (161), 239, 324);
- Add_Goto (Table.States (161), 272, 92);
- Add_Goto (Table.States (161), 293, 97);
- Table.States (161).Kernel := To_Vector ((0 => (215, 50, 4,
False)));
- Table.States (161).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (162).Action_List.Set_Capacity (1);
- Add_Action (Table.States (162), 104, 325);
- Table.States (162).Kernel := To_Vector (((201, 69, 4, False),
(201, 69, 4, False), (201, 69, 2, False)));
- Table.States (162).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 325)));
- Table.States (163).Action_List.Set_Capacity (3);
- Add_Action (Table.States (163), 29, 7);
- Add_Action (Table.States (163), 47, 326);
- Add_Action (Table.States (163), 50, 18);
- Table.States (163).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (163), 207, 61);
- Add_Goto (Table.States (163), 262, 87);
- Add_Goto (Table.States (163), 312, 327);
- Table.States (163).Kernel := To_Vector (((200, 74, 6, False),
(200, 74, 5, False), (200, 74, 5, False),
- (200, 74, 3, False), (204, 74, 6, False)));
- Table.States (163).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 50, 18)));
- Table.States (164).Action_List.Set_Capacity (2);
- Add_Action (Table.States (164), (81, 83), (219, 1), 1,
identifier_list_1'Access, null);
- Table.States (164).Kernel := To_Vector ((0 => (219, 104, 0,
False)));
- Table.States (164).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 219, 1)));
- Table.States (165).Action_List.Set_Capacity (8);
- Add_Action (Table.States (165), (29, 47, 48, 50, 69, 71, 74, 104),
(212, 0), 1, null, null);
- Table.States (165).Kernel := To_Vector ((0 => (212, 198, 0,
False)));
- Table.States (165).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 212, 1)));
+ Add_Goto (Table.States (161), 129, 42);
+ Add_Goto (Table.States (161), 240, 324);
+ Add_Goto (Table.States (161), 273, 93);
+ Add_Goto (Table.States (161), 294, 98);
+ Table.States (161).Kernel := To_Vector ((0 => (216, 47, 4,
False)));
+ Table.States (161).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (162).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (162), 79, 31);
+ Add_Action (Table.States (162), 105, 120);
+ Add_Action (Table.States (162), 106, 34);
+ Add_Action (Table.States (162), 107, 35);
+ Table.States (162).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (162), 129, 42);
+ Add_Goto (Table.States (162), 240, 325);
+ Add_Goto (Table.States (162), 273, 93);
+ Add_Goto (Table.States (162), 294, 98);
+ Table.States (162).Kernel := To_Vector ((0 => (216, 50, 4,
False)));
+ Table.States (162).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (163).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (163), 105, 326);
+ Table.States (163).Kernel := To_Vector (((202, 69, 4, False),
(202, 69, 4, False), (202, 69, 2, False)));
+ Table.States (163).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 326)));
+ Table.States (164).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (164), 29, 7);
+ Add_Action (Table.States (164), 47, 327);
+ Add_Action (Table.States (164), 50, 18);
+ Table.States (164).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (164), 208, 62);
+ Add_Goto (Table.States (164), 263, 88);
+ Add_Goto (Table.States (164), 313, 328);
+ Table.States (164).Kernel := To_Vector (((201, 74, 6, False),
(201, 74, 5, False), (201, 74, 5, False),
+ (201, 74, 3, False), (205, 74, 6, False)));
+ Table.States (164).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 50, 18)));
+ Table.States (165).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (165), (82, 84), (220, 1), 1,
identifier_list_1'Access, null);
+ Table.States (165).Kernel := To_Vector ((0 => (220, 105, 0,
False)));
+ Table.States (165).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 220, 1)));
Table.States (166).Action_List.Set_Capacity (8);
- Add_Action (Table.States (166), (29, 47, 48, 50, 69, 71, 74, 104),
(212, 2), 1, null, null);
- Table.States (166).Kernel := To_Vector ((0 => (212, 200, 0,
False)));
- Table.States (166).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 212, 1)));
+ Add_Action (Table.States (166), (29, 47, 48, 50, 69, 71, 74, 105),
(213, 0), 1, null, null);
+ Table.States (166).Kernel := To_Vector ((0 => (213, 199, 0,
False)));
+ Table.States (166).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 213, 1)));
Table.States (167).Action_List.Set_Capacity (8);
- Add_Action (Table.States (167), (29, 47, 48, 50, 69, 71, 74, 104),
(212, 1), 1, null, null);
- Table.States (167).Kernel := To_Vector ((0 => (212, 201, 0,
False)));
- Table.States (167).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 212, 1)));
+ Add_Action (Table.States (167), (29, 47, 48, 50, 69, 71, 74, 105),
(213, 2), 1, null, null);
+ Table.States (167).Kernel := To_Vector ((0 => (213, 201, 0,
False)));
+ Table.States (167).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 213, 1)));
Table.States (168).Action_List.Set_Capacity (8);
- Add_Action (Table.States (168), (29, 47, 48, 50, 69, 71, 74, 104),
(212, 3), 1, null, null);
- Table.States (168).Kernel := To_Vector ((0 => (212, 204, 0,
False)));
- Table.States (168).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 212, 1)));
+ Add_Action (Table.States (168), (29, 47, 48, 50, 69, 71, 74, 105),
(213, 1), 1, null, null);
+ Table.States (168).Kernel := To_Vector ((0 => (213, 202, 0,
False)));
+ Table.States (168).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 213, 1)));
Table.States (169).Action_List.Set_Capacity (8);
- Add_Action (Table.States (169), 29, Reduce, (210, 0), 2,
generic_formal_part_0'Access, null);
- Add_Action (Table.States (169), 47, Reduce, (210, 0), 2,
generic_formal_part_0'Access, null);
- Add_Action (Table.States (169), 48, 16);
- Add_Action (Table.States (169), 50, Reduce, (210, 0), 2,
generic_formal_part_0'Access, null);
- Add_Action (Table.States (169), 69, 162);
- Add_Action (Table.States (169), 71, 28);
- Add_Action (Table.States (169), 74, 163);
- Add_Action (Table.States (169), 104, 164);
- Table.States (169).Goto_List.Set_Capacity (8);
- Add_Goto (Table.States (169), 198, 165);
- Add_Goto (Table.States (169), 200, 166);
- Add_Goto (Table.States (169), 201, 167);
- Add_Goto (Table.States (169), 204, 168);
- Add_Goto (Table.States (169), 212, 328);
- Add_Goto (Table.States (169), 219, 171);
- Add_Goto (Table.States (169), 257, 172);
- Add_Goto (Table.States (169), 331, 173);
- Table.States (169).Kernel := To_Vector (((210, 211, 0, False),
(211, 211, 3, True)));
- Table.States (169).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 210, 2)));
+ Add_Action (Table.States (169), (29, 47, 48, 50, 69, 71, 74, 105),
(213, 3), 1, null, null);
+ Table.States (169).Kernel := To_Vector ((0 => (213, 205, 0,
False)));
+ Table.States (169).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 213, 1)));
Table.States (170).Action_List.Set_Capacity (8);
- Add_Action (Table.States (170), (29, 47, 48, 50, 69, 71, 74, 104),
(211, 1), 1, null, null);
- Table.States (170).Kernel := To_Vector ((0 => (211, 212, 0,
False)));
- Table.States (170).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 211, 1)));
- Table.States (171).Action_List.Set_Capacity (2);
- Add_Action (Table.States (171), 81, 329);
- Add_Action (Table.States (171), 83, 234);
- Table.States (171).Kernel := To_Vector (((198, 219, 4, False),
(198, 219, 5, False), (198, 219, 3, False),
- (198, 219, 4, False), (219, 219, 2, True)));
- Table.States (171).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 81, 329)));
- Table.States (172).Action_List.Set_Capacity (8);
- Add_Action (Table.States (172), (29, 47, 48, 50, 69, 71, 74, 104),
(212, 4), 1, null, null);
- Table.States (172).Kernel := To_Vector ((0 => (212, 257, 0,
False)));
- Table.States (172).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 212, 1)));
+ Add_Action (Table.States (170), 29, Reduce, (211, 0), 2,
generic_formal_part_0'Access, null);
+ Add_Action (Table.States (170), 47, Reduce, (211, 0), 2,
generic_formal_part_0'Access, null);
+ Add_Action (Table.States (170), 48, 16);
+ Add_Action (Table.States (170), 50, Reduce, (211, 0), 2,
generic_formal_part_0'Access, null);
+ Add_Action (Table.States (170), 69, 163);
+ Add_Action (Table.States (170), 71, 28);
+ Add_Action (Table.States (170), 74, 164);
+ Add_Action (Table.States (170), 105, 165);
+ Table.States (170).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (170), 199, 166);
+ Add_Goto (Table.States (170), 201, 167);
+ Add_Goto (Table.States (170), 202, 168);
+ Add_Goto (Table.States (170), 205, 169);
+ Add_Goto (Table.States (170), 213, 329);
+ Add_Goto (Table.States (170), 220, 172);
+ Add_Goto (Table.States (170), 258, 173);
+ Add_Goto (Table.States (170), 332, 174);
+ Table.States (170).Kernel := To_Vector (((211, 212, 0, False),
(212, 212, 3, True)));
+ Table.States (170).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 211, 2)));
+ Table.States (171).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (171), (29, 47, 48, 50, 69, 71, 74, 105),
(212, 1), 1, null, null);
+ Table.States (171).Kernel := To_Vector ((0 => (212, 213, 0,
False)));
+ Table.States (171).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 212, 1)));
+ Table.States (172).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (172), 82, 330);
+ Add_Action (Table.States (172), 84, 235);
+ Table.States (172).Kernel := To_Vector (((199, 220, 4, False),
(199, 220, 5, False), (199, 220, 3, False),
+ (199, 220, 4, False), (220, 220, 2, True)));
+ Table.States (172).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 82, 330)));
Table.States (173).Action_List.Set_Capacity (8);
- Add_Action (Table.States (173), (29, 47, 48, 50, 69, 71, 74, 104),
(212, 5), 1, null, null);
- Table.States (173).Kernel := To_Vector ((0 => (212, 331, 0,
False)));
- Table.States (173).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 212, 1)));
- Table.States (174).Action_List.Set_Capacity (1);
- Add_Action (Table.States (174), 96, 330);
- Table.States (174).Kernel := To_Vector ((0 => (303, 104, 1,
False)));
- Table.States (174).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 330)));
+ Add_Action (Table.States (173), (29, 47, 48, 50, 69, 71, 74, 105),
(213, 4), 1, null, null);
+ Table.States (173).Kernel := To_Vector ((0 => (213, 258, 0,
False)));
+ Table.States (173).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 213, 1)));
+ Table.States (174).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (174), (29, 47, 48, 50, 69, 71, 74, 105),
(213, 5), 1, null, null);
+ Table.States (174).Kernel := To_Vector ((0 => (213, 332, 0,
False)));
+ Table.States (174).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 213, 1)));
Table.States (175).Action_List.Set_Capacity (1);
- Add_Action (Table.States (175), 68, 331);
- Table.States (175).Kernel := To_Vector (((222, 192, 7, False),
(222, 192, 5, False), (222, 192, 6, False),
- (222, 192, 4, False)));
- Table.States (175).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 68, 331)));
+ Add_Action (Table.States (175), 97, 331);
+ Table.States (175).Kernel := To_Vector ((0 => (304, 105, 1,
False)));
+ Table.States (175).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 331)));
Table.States (176).Action_List.Set_Capacity (1);
- Add_Action (Table.States (176), 74, 332);
- Table.States (176).Kernel := To_Vector ((0 => (332, 49, 3,
False)));
- Table.States (176).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 74, 332)));
- Table.States (177).Action_List.Set_Capacity (3);
- Add_Action (Table.States (177), 104, 119);
- Add_Action (Table.States (177), 105, 33);
- Add_Action (Table.States (177), 106, 34);
- Table.States (177).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (177), 128, 41);
- Add_Goto (Table.States (177), 238, 333);
- Add_Goto (Table.States (177), 239, 219);
- Add_Goto (Table.States (177), 272, 92);
- Add_Goto (Table.States (177), 293, 97);
- Table.States (177).Kernel := To_Vector ((0 => (332, 74, 2,
False)));
- Table.States (177).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (178).Action_List.Set_Capacity (3);
- Add_Action (Table.States (178), (25, 29, 50), (246, 0), 2,
overriding_indicator_opt_0'Access, null);
- Table.States (178).Kernel := To_Vector ((0 => (246, 46, 0,
False)));
- Table.States (178).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 246, 2)));
- Table.States (179).Action_List.Set_Capacity (46);
- Add_Action (Table.States (179), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (303, 0), 2, simple_statement_0'Access, null);
- Table.States (179).Kernel := To_Vector ((0 => (303, 96, 0,
False)));
- Table.States (179).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 303, 2)));
- Table.States (180).Action_List.Set_Capacity (3);
- Add_Action (Table.States (180), 104, 119);
- Add_Action (Table.States (180), 105, 33);
- Add_Action (Table.States (180), 106, 34);
- Table.States (180).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (180), 128, 41);
- Add_Goto (Table.States (180), 239, 334);
- Add_Goto (Table.States (180), 272, 92);
- Add_Goto (Table.States (180), 293, 97);
- Table.States (180).Kernel := To_Vector (((247, 14, 5, False),
(247, 14, 4, False), (248, 14, 4, False)));
- Table.States (180).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (181).Action_List.Set_Capacity (7);
- Add_Action (Table.States (181), 35, 335);
- Add_Conflict (Table.States (181), 35, (122, 1), 0, null, null);
- Add_Action (Table.States (181), 56, 336);
- Add_Action (Table.States (181), 74, 337);
- Add_Action (Table.States (181), 76, 235);
- Add_Action (Table.States (181), 84, 237);
- Add_Action (Table.States (181), 101, 239);
- Add_Action (Table.States (181), 102, 240);
- Table.States (181).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (181), 115, 241);
- Add_Goto (Table.States (181), 122, 338);
- Add_Goto (Table.States (181), 322, 242);
- Table.States (181).Kernel := To_Vector (((128, 239, 2, True),
(213, 239, 4, False), (239, 239, 5, True),
- (239, 239, 2, True), (250, 239, 3, False), (251, 239, 3, False),
(251, 239, 2, False), (272, 239, 3, True),
- (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
- Table.States (181).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (182).Action_List.Set_Capacity (2);
- Add_Action (Table.States (182), 76, 339);
- Add_Action (Table.States (182), 96, 340);
- Table.States (182).Kernel := To_Vector (((257, 104, 3, False),
(257, 104, 5, False), (257, 104, 1,
+ Add_Action (Table.States (176), 68, 332);
+ Table.States (176).Kernel := To_Vector (((223, 193, 7, False),
(223, 193, 5, False), (223, 193, 6, False),
+ (223, 193, 4, False)));
+ Table.States (176).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 68, 332)));
+ Table.States (177).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (177), 74, 333);
+ Table.States (177).Kernel := To_Vector ((0 => (333, 49, 3,
False)));
+ Table.States (177).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 74, 333)));
+ Table.States (178).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (178), 79, 31);
+ Add_Action (Table.States (178), 105, 120);
+ Add_Action (Table.States (178), 106, 34);
+ Add_Action (Table.States (178), 107, 35);
+ Table.States (178).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (178), 129, 42);
+ Add_Goto (Table.States (178), 239, 334);
+ Add_Goto (Table.States (178), 240, 220);
+ Add_Goto (Table.States (178), 273, 93);
+ Add_Goto (Table.States (178), 294, 98);
+ Table.States (178).Kernel := To_Vector ((0 => (333, 74, 2,
False)));
+ Table.States (178).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (179).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (179), (25, 29, 50), (247, 0), 2,
overriding_indicator_opt_0'Access, null);
+ Table.States (179).Kernel := To_Vector ((0 => (247, 46, 0,
False)));
+ Table.States (179).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 247, 2)));
+ Table.States (180).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (180), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (304, 0), 2, simple_statement_0'Access, null);
+ Table.States (180).Kernel := To_Vector ((0 => (304, 97, 0,
False)));
+ Table.States (180).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 304, 2)));
+ Table.States (181).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (181), 79, 31);
+ Add_Action (Table.States (181), 105, 120);
+ Add_Action (Table.States (181), 106, 34);
+ Add_Action (Table.States (181), 107, 35);
+ Table.States (181).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (181), 129, 42);
+ Add_Goto (Table.States (181), 240, 335);
+ Add_Goto (Table.States (181), 273, 93);
+ Add_Goto (Table.States (181), 294, 98);
+ Table.States (181).Kernel := To_Vector (((248, 14, 5, False),
(248, 14, 4, False), (249, 14, 4, False)));
+ Table.States (181).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (182).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (182), 35, 336);
+ Add_Conflict (Table.States (182), 35, (123, 1), 0, null, null);
+ Add_Action (Table.States (182), 56, 337);
+ Add_Action (Table.States (182), 74, 338);
+ Add_Action (Table.States (182), 76, 236);
+ Add_Action (Table.States (182), 85, 238);
+ Add_Action (Table.States (182), 102, 240);
+ Add_Action (Table.States (182), 103, 241);
+ Table.States (182).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (182), 116, 242);
+ Add_Goto (Table.States (182), 123, 339);
+ Add_Goto (Table.States (182), 323, 243);
+ Table.States (182).Kernel := To_Vector (((129, 240, 2, True),
(214, 240, 4, False), (240, 240, 5, True),
+ (240, 240, 2, True), (251, 240, 3, False), (252, 240, 3, False),
(252, 240, 2, False), (273, 240, 3, True),
+ (294, 240, 2, True), (294, 240, 2, True), (294, 240, 2, True),
(294, 240, 2, True)));
+ Table.States (182).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (183).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (183), 76, 340);
+ Add_Action (Table.States (183), 97, 341);
+ Table.States (183).Kernel := To_Vector (((258, 105, 3, False),
(258, 105, 5, False), (258, 105, 1,
False)));
- Table.States (182).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 340)));
- Table.States (183).Action_List.Set_Capacity (3);
- Add_Action (Table.States (183), 104, 341);
- Add_Action (Table.States (183), 105, 152);
- Add_Action (Table.States (183), 106, 34);
- Table.States (183).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (183), 128, 153);
- Add_Goto (Table.States (183), 163, 154);
- Add_Goto (Table.States (183), 239, 157);
- Add_Goto (Table.States (183), 272, 92);
- Add_Goto (Table.States (183), 293, 97);
- Table.States (183).Kernel := To_Vector (((121, 28, 5, False),
(127, 28, 4, False), (182, 28, 5, False),
- (281, 28, 14, False)));
- Table.States (183).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 341)));
- Table.States (184).Action_List.Set_Capacity (3);
- Add_Action (Table.States (184), 104, 119);
- Add_Action (Table.States (184), 105, 33);
- Add_Action (Table.States (184), 106, 34);
+ Table.States (183).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 341)));
+ Table.States (184).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (184), 79, 31);
+ Add_Action (Table.States (184), 105, 342);
+ Add_Action (Table.States (184), 106, 153);
+ Add_Action (Table.States (184), 107, 35);
Table.States (184).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (184), 128, 41);
- Add_Goto (Table.States (184), 238, 342);
- Add_Goto (Table.States (184), 239, 219);
- Add_Goto (Table.States (184), 272, 92);
- Add_Goto (Table.States (184), 293, 97);
- Table.States (184).Kernel := To_Vector ((0 => (332, 74, 2,
False)));
- Table.States (184).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (185).Action_List.Set_Capacity (2);
- Add_Action (Table.States (185), 81, 343);
- Add_Conflict (Table.States (185), 81, (219, 1), 1,
identifier_list_1'Access, null);
- Add_Action (Table.States (185), 83, Reduce, (219, 1), 1,
identifier_list_1'Access, null);
- Table.States (185).Kernel := To_Vector (((219, 104, 0, False),
(245, 104, 5, False), (245, 104, 6, False),
- (245, 104, 5, False)));
- Table.States (185).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 219, 1)));
- Table.States (186).Action_List.Set_Capacity (39);
- Add_Action (Table.States (186), (4, 5, 13, 15, 17, 18, 25, 27, 28,
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
- 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93,
104, 105, 106, 107), (142, 2), 2,
+ Add_Goto (Table.States (184), 129, 154);
+ Add_Goto (Table.States (184), 164, 155);
+ Add_Goto (Table.States (184), 240, 158);
+ Add_Goto (Table.States (184), 273, 93);
+ Add_Goto (Table.States (184), 294, 98);
+ Table.States (184).Kernel := To_Vector (((122, 28, 5, False),
(128, 28, 4, False), (183, 28, 5, False),
+ (282, 28, 14, False)));
+ Table.States (184).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 342)));
+ Table.States (185).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (185), 79, 31);
+ Add_Action (Table.States (185), 105, 120);
+ Add_Action (Table.States (185), 106, 34);
+ Add_Action (Table.States (185), 107, 35);
+ Table.States (185).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (185), 129, 42);
+ Add_Goto (Table.States (185), 239, 343);
+ Add_Goto (Table.States (185), 240, 220);
+ Add_Goto (Table.States (185), 273, 93);
+ Add_Goto (Table.States (185), 294, 98);
+ Table.States (185).Kernel := To_Vector ((0 => (333, 74, 2,
False)));
+ Table.States (185).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (186).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (186), 82, 344);
+ Add_Conflict (Table.States (186), 82, (220, 1), 1,
identifier_list_1'Access, null);
+ Add_Action (Table.States (186), 84, Reduce, (220, 1), 1,
identifier_list_1'Access, null);
+ Table.States (186).Kernel := To_Vector (((220, 105, 0, False),
(246, 105, 5, False), (246, 105, 6, False),
+ (246, 105, 5, False)));
+ Table.States (186).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 220, 1)));
+ Table.States (187).Action_List.Set_Capacity (40);
+ Add_Action (Table.States (187), (4, 5, 13, 15, 17, 18, 25, 27, 28,
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
+ 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 79,
94, 105, 106, 107, 108), (143, 2), 2,
compilation_unit_2'Access, null);
- Table.States (186).Kernel := To_Vector ((0 => (142, 157, 0,
False)));
- Table.States (186).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 142, 2)));
- Table.States (187).Action_List.Set_Capacity (7);
- Add_Action (Table.States (187), 35, Reduce, (253, 1), 0, null,
null);
- Add_Action (Table.States (187), 74, Reduce, (253, 1), 0, null,
null);
- Add_Action (Table.States (187), 76, 318);
- Add_Action (Table.States (187), 84, 237);
- Add_Action (Table.States (187), 96, Reduce, (253, 1), 0, null,
null);
- Add_Action (Table.States (187), 101, 239);
- Add_Action (Table.States (187), 102, 240);
- Table.States (187).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (187), 115, 241);
- Add_Goto (Table.States (187), 199, 344);
- Add_Goto (Table.States (187), 253, 345);
- Add_Goto (Table.States (187), 322, 242);
- Table.States (187).Kernel := To_Vector (((128, 239, 2, True),
(239, 239, 5, True), (239, 239, 2, True),
- (262, 239, 0, False), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (187).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 253, 0)));
- Table.States (188).Action_List.Set_Capacity (1);
- Add_Action (Table.States (188), 104, 346);
- Table.States (188).Kernel := To_Vector (((264, 14, 4, False),
(265, 14, 4, False)));
- Table.States (188).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 346)));
+ Table.States (187).Kernel := To_Vector ((0 => (143, 158, 0,
False)));
+ Table.States (187).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 143, 2)));
+ Table.States (188).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (188), 35, Reduce, (254, 1), 0, null,
null);
+ Add_Action (Table.States (188), 74, Reduce, (254, 1), 0, null,
null);
+ Add_Action (Table.States (188), 76, 319);
+ Add_Action (Table.States (188), 85, 238);
+ Add_Action (Table.States (188), 97, Reduce, (254, 1), 0, null,
null);
+ Add_Action (Table.States (188), 102, 240);
+ Add_Action (Table.States (188), 103, 241);
+ Table.States (188).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (188), 116, 242);
+ Add_Goto (Table.States (188), 200, 345);
+ Add_Goto (Table.States (188), 254, 346);
+ Add_Goto (Table.States (188), 323, 243);
+ Table.States (188).Kernel := To_Vector (((129, 240, 2, True),
(240, 240, 5, True), (240, 240, 2, True),
+ (263, 240, 0, False), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (188).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 254, 0)));
Table.States (189).Action_List.Set_Capacity (1);
- Add_Action (Table.States (189), 104, 347);
- Table.States (189).Kernel := To_Vector (((271, 69, 7, False),
(271, 69, 4, False)));
- Table.States (189).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 347)));
- Table.States (190).Action_List.Set_Capacity (2);
- Add_Action (Table.States (190), 35, Reduce, (122, 1), 0, null,
null);
- Add_Action (Table.States (190), 74, 337);
- Table.States (190).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (190), 122, 348);
- Table.States (190).Kernel := To_Vector (((304, 104, 6, False),
(304, 104, 3, False)));
- Table.States (190).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (191).Action_List.Set_Capacity (46);
- Add_Action (Table.States (191), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (276, 2), 2, raise_statement_2'Access, null);
- Table.States (191).Kernel := To_Vector ((0 => (276, 96, 0,
False)));
- Table.States (191).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 276, 2)));
- Table.States (192).Action_List.Set_Capacity (6);
- Add_Action (Table.States (192), 74, 349);
- Add_Action (Table.States (192), 76, 235);
- Add_Action (Table.States (192), 84, 237);
- Add_Action (Table.States (192), 96, 350);
- Add_Action (Table.States (192), 101, 239);
- Add_Action (Table.States (192), 102, 240);
- Table.States (192).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (192), 115, 241);
- Add_Goto (Table.States (192), 322, 242);
- Table.States (192).Kernel := To_Vector (((128, 239, 2, True),
(239, 239, 5, True), (239, 239, 2, True),
- (272, 239, 3, True), (276, 239, 2, False), (276, 239, 1, False),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True), (293, 239, 2, True)));
- Table.States (192).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 350)));
+ Add_Action (Table.States (189), 105, 347);
+ Table.States (189).Kernel := To_Vector (((265, 14, 4, False),
(266, 14, 4, False)));
+ Table.States (189).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 347)));
+ Table.States (190).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (190), 105, 348);
+ Table.States (190).Kernel := To_Vector (((272, 69, 7, False),
(272, 69, 4, False)));
+ Table.States (190).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 348)));
+ Table.States (191).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (191), 35, Reduce, (123, 1), 0, null,
null);
+ Add_Action (Table.States (191), 74, 338);
+ Table.States (191).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (191), 123, 349);
+ Table.States (191).Kernel := To_Vector (((305, 105, 6, False),
(305, 105, 3, False)));
+ Table.States (191).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (192).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (192), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (277, 2), 2, raise_statement_2'Access, null);
+ Table.States (192).Kernel := To_Vector ((0 => (277, 97, 0,
False)));
+ Table.States (192).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 277, 2)));
Table.States (193).Action_List.Set_Capacity (6);
- Add_Action (Table.States (193), 74, 351);
- Add_Action (Table.States (193), 76, 235);
- Add_Action (Table.States (193), 84, 237);
- Add_Action (Table.States (193), 96, 352);
- Add_Action (Table.States (193), 101, 239);
+ Add_Action (Table.States (193), 74, 350);
+ Add_Action (Table.States (193), 76, 236);
+ Add_Action (Table.States (193), 85, 238);
+ Add_Action (Table.States (193), 97, 351);
Add_Action (Table.States (193), 102, 240);
+ Add_Action (Table.States (193), 103, 241);
Table.States (193).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (193), 115, 241);
- Add_Goto (Table.States (193), 322, 242);
- Table.States (193).Kernel := To_Vector (((128, 239, 2, True),
(239, 239, 5, True), (239, 239, 2, True),
- (272, 239, 3, True), (290, 239, 3, False), (290, 239, 1, False),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True), (293, 239, 2, True)));
- Table.States (193).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 352)));
- Table.States (194).Action_List.Set_Capacity (25);
- Add_Action (Table.States (194), 10, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (194), 33, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (194), 38, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (194), 40, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (194), 43, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (194), 55, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (194), 75, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (194), 76, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (194), 78, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (194), 81, 353);
- Add_Action (Table.States (194), 84, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (194), 86, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (194), 88, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (194), 89, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (194), 91, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (194), 92, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (194), 94, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (194), 95, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (194), 96, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (194), 97, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (194), 98, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (194), 99, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (194), 100, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (194), 101, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (194), 102, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Table.States (194).Kernel := To_Vector (((194, 104, 3, False),
(194, 104, 2, False), (239, 104, 0,
+ Add_Goto (Table.States (193), 116, 242);
+ Add_Goto (Table.States (193), 323, 243);
+ Table.States (193).Kernel := To_Vector (((129, 240, 2, True),
(240, 240, 5, True), (240, 240, 2, True),
+ (273, 240, 3, True), (277, 240, 2, False), (277, 240, 1, False),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True), (294, 240, 2, True)));
+ Table.States (193).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 351)));
+ Table.States (194).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (194), 74, 352);
+ Add_Action (Table.States (194), 76, 236);
+ Add_Action (Table.States (194), 85, 238);
+ Add_Action (Table.States (194), 97, 353);
+ Add_Action (Table.States (194), 102, 240);
+ Add_Action (Table.States (194), 103, 241);
+ Table.States (194).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (194), 116, 242);
+ Add_Goto (Table.States (194), 323, 243);
+ Table.States (194).Kernel := To_Vector (((129, 240, 2, True),
(240, 240, 5, True), (240, 240, 2, True),
+ (273, 240, 3, True), (291, 240, 3, False), (291, 240, 1, False),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True), (294, 240, 2, True)));
+ Table.States (194).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 353)));
+ Table.States (195).Action_List.Set_Capacity (25);
+ Add_Action (Table.States (195), 10, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (195), 33, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (195), 38, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (195), 40, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (195), 43, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (195), 55, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (195), 75, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (195), 76, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (195), 78, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (195), 82, 354);
+ Add_Action (Table.States (195), 85, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (195), 87, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (195), 89, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (195), 90, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (195), 92, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (195), 93, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (195), 95, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (195), 96, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (195), 97, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (195), 98, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (195), 99, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (195), 100, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (195), 101, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (195), 102, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (195), 103, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Table.States (195).Kernel := To_Vector (((195, 105, 3, False),
(195, 105, 2, False), (240, 105, 0,
False)));
- Table.States (194).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 239, 1)));
- Table.States (195).Action_List.Set_Capacity (1);
- Add_Action (Table.States (195), 96, 354);
- Table.States (195).Kernel := To_Vector ((0 => (302, 192, 1,
False)));
- Table.States (195).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 354)));
- Table.States (196).Action_List.Set_Capacity (2);
- Add_Action (Table.States (196), 21, Reduce, (195, 0), 1, null,
null);
- Add_Action (Table.States (196), 96, 355);
- Table.States (196).Kernel := To_Vector (((195, 194, 0, False),
(196, 194, 1, False)));
- Table.States (196).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 195, 1)));
- Table.States (197).Action_List.Set_Capacity (1);
- Add_Action (Table.States (197), 21, 356);
- Table.States (197).Kernel := To_Vector ((0 => (196, 195, 4,
False)));
- Table.States (197).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 21, 356)));
- Table.States (198).Action_List.Set_Capacity (3);
- Add_Action (Table.States (198), 104, 119);
- Add_Action (Table.States (198), 105, 33);
- Add_Action (Table.States (198), 106, 34);
- Table.States (198).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (198), 128, 41);
- Add_Goto (Table.States (198), 239, 357);
- Add_Goto (Table.States (198), 272, 92);
- Add_Goto (Table.States (198), 293, 97);
- Table.States (198).Kernel := To_Vector ((0 => (315, 76, 8,
False)));
- Table.States (198).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (199).Action_List.Set_Capacity (1);
- Add_Action (Table.States (199), 96, 358);
- Table.States (199).Kernel := To_Vector ((0 => (295, 67, 1,
False)));
- Table.States (199).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 358)));
- Table.States (200).Action_List.Set_Capacity (13);
- Add_Action (Table.States (200), 3, 121);
- Add_Action (Table.States (200), 39, 122);
- Add_Action (Table.States (200), 40, 123);
- Add_Action (Table.States (200), 41, 124);
- Add_Action (Table.States (200), 52, 125);
- Add_Action (Table.States (200), 76, 126);
- Add_Action (Table.States (200), 87, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (200), 94, 127);
- Add_Action (Table.States (200), 95, 128);
- Add_Action (Table.States (200), 103, 129);
- Add_Action (Table.States (200), 104, 119);
- Add_Action (Table.States (200), 105, 33);
- Add_Action (Table.States (200), 106, 34);
- Table.States (200).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (200), 117, 130);
- Add_Goto (Table.States (200), 128, 41);
- Add_Goto (Table.States (200), 191, 131);
- Add_Goto (Table.States (200), 192, 359);
- Add_Goto (Table.States (200), 197, 133);
- Add_Goto (Table.States (200), 239, 134);
- Add_Goto (Table.States (200), 258, 135);
- Add_Goto (Table.States (200), 272, 92);
- Add_Goto (Table.States (200), 275, 136);
- Add_Goto (Table.States (200), 282, 137);
- Add_Goto (Table.States (200), 283, 138);
- Add_Goto (Table.States (200), 284, 139);
- Add_Goto (Table.States (200), 285, 140);
- Add_Goto (Table.States (200), 286, 141);
- Add_Goto (Table.States (200), 287, 142);
- Add_Goto (Table.States (200), 293, 97);
- Add_Goto (Table.States (200), 301, 143);
- Add_Goto (Table.States (200), 320, 144);
- Add_Goto (Table.States (200), 321, 145);
- Add_Goto (Table.States (200), 330, 146);
- Table.States (200).Kernel := To_Vector (((295, 72, 4, False),
(295, 72, 3, False), (295, 72, 3, False)));
- Table.States (200).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
+ Table.States (195).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 240, 1)));
end Subr_3;
procedure Subr_4
is begin
- Table.States (201).Action_List.Set_Capacity (25);
- Add_Action (Table.States (201), 4, 1);
- Add_Action (Table.States (201), 5, 2);
- Add_Action (Table.States (201), 13, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (201), 15, 3);
- Add_Action (Table.States (201), 17, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (201), 18, 4);
- Add_Action (Table.States (201), 22, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (201), 24, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (201), 27, 5);
- Add_Action (Table.States (201), 28, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (201), 31, 9);
- Add_Action (Table.States (201), 32, 10);
- Add_Action (Table.States (201), 37, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (201), 41, 13);
- Add_Action (Table.States (201), 43, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (201), 48, 16);
- Add_Action (Table.States (201), 52, 20);
- Add_Action (Table.States (201), 57, 21);
- Add_Action (Table.States (201), 58, 22);
- Add_Action (Table.States (201), 61, 24);
- Add_Action (Table.States (201), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (201), 93, 31);
- Add_Action (Table.States (201), 104, 360);
- Add_Action (Table.States (201), 105, 33);
+ Table.States (196).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (196), 97, 355);
+ Table.States (196).Kernel := To_Vector ((0 => (303, 193, 1,
False)));
+ Table.States (196).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 355)));
+ Table.States (197).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (197), 21, Reduce, (196, 0), 1, null,
null);
+ Add_Action (Table.States (197), 97, 356);
+ Table.States (197).Kernel := To_Vector (((196, 195, 0, False),
(197, 195, 1, False)));
+ Table.States (197).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 196, 1)));
+ Table.States (198).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (198), 21, 357);
+ Table.States (198).Kernel := To_Vector ((0 => (197, 196, 4,
False)));
+ Table.States (198).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 21, 357)));
+ Table.States (199).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (199), 79, 31);
+ Add_Action (Table.States (199), 105, 120);
+ Add_Action (Table.States (199), 106, 34);
+ Add_Action (Table.States (199), 107, 35);
+ Table.States (199).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (199), 129, 42);
+ Add_Goto (Table.States (199), 240, 358);
+ Add_Goto (Table.States (199), 273, 93);
+ Add_Goto (Table.States (199), 294, 98);
+ Table.States (199).Kernel := To_Vector ((0 => (316, 76, 8,
False)));
+ Table.States (199).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (200).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (200), 97, 359);
+ Table.States (200).Kernel := To_Vector ((0 => (296, 67, 1,
False)));
+ Table.States (200).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 359)));
+ Table.States (201).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (201), 3, 122);
+ Add_Action (Table.States (201), 39, 123);
+ Add_Action (Table.States (201), 40, 124);
+ Add_Action (Table.States (201), 41, 125);
+ Add_Action (Table.States (201), 52, 126);
+ Add_Action (Table.States (201), 76, 127);
+ Add_Action (Table.States (201), 79, 31);
+ Add_Action (Table.States (201), 88, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (201), 95, 128);
+ Add_Action (Table.States (201), 96, 129);
+ Add_Action (Table.States (201), 104, 130);
+ Add_Action (Table.States (201), 105, 120);
Add_Action (Table.States (201), 106, 34);
- Table.States (201).Goto_List.Set_Capacity (31);
- Add_Goto (Table.States (201), 113, 36);
- Add_Goto (Table.States (201), 123, 38);
- Add_Goto (Table.States (201), 126, 39);
- Add_Goto (Table.States (201), 128, 41);
- Add_Goto (Table.States (201), 131, 42);
- Add_Goto (Table.States (201), 132, 43);
- Add_Goto (Table.States (201), 133, 44);
- Add_Goto (Table.States (201), 139, 47);
- Add_Goto (Table.States (201), 151, 50);
- Add_Goto (Table.States (201), 152, 51);
- Add_Goto (Table.States (201), 161, 53);
- Add_Goto (Table.States (201), 190, 57);
- Add_Goto (Table.States (201), 196, 59);
- Add_Goto (Table.States (201), 217, 68);
- Add_Goto (Table.States (201), 222, 70);
- Add_Goto (Table.States (201), 232, 72);
- Add_Goto (Table.States (201), 239, 73);
- Add_Goto (Table.States (201), 257, 83);
- Add_Goto (Table.States (201), 261, 86);
- Add_Goto (Table.States (201), 272, 92);
- Add_Goto (Table.States (201), 276, 93);
- Add_Goto (Table.States (201), 290, 96);
- Add_Goto (Table.States (201), 293, 97);
+ Add_Action (Table.States (201), 107, 35);
+ Table.States (201).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (201), 118, 131);
+ Add_Goto (Table.States (201), 129, 42);
+ Add_Goto (Table.States (201), 192, 132);
+ Add_Goto (Table.States (201), 193, 360);
+ Add_Goto (Table.States (201), 198, 134);
+ Add_Goto (Table.States (201), 240, 135);
+ Add_Goto (Table.States (201), 259, 136);
+ Add_Goto (Table.States (201), 273, 93);
+ Add_Goto (Table.States (201), 276, 137);
+ Add_Goto (Table.States (201), 283, 138);
+ Add_Goto (Table.States (201), 284, 139);
+ Add_Goto (Table.States (201), 285, 140);
+ Add_Goto (Table.States (201), 286, 141);
+ Add_Goto (Table.States (201), 287, 142);
+ Add_Goto (Table.States (201), 288, 143);
Add_Goto (Table.States (201), 294, 98);
- Add_Goto (Table.States (201), 298, 99);
- Add_Goto (Table.States (201), 299, 361);
- Add_Goto (Table.States (201), 300, 362);
- Add_Goto (Table.States (201), 302, 100);
- Add_Goto (Table.States (201), 303, 101);
- Add_Goto (Table.States (201), 306, 363);
- Add_Goto (Table.States (201), 323, 114);
- Table.States (201).Kernel := To_Vector ((0 => (295, 113, 0,
False)));
- Table.States (201).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 300, 0)));
- Table.States (202).Action_List.Set_Capacity (3);
- Add_Action (Table.States (202), (22, 24, 43), (295, 5), 1, null,
null);
- Table.States (202).Kernel := To_Vector ((0 => (295, 160, 0,
False)));
- Table.States (202).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 295, 1)));
- Table.States (203).Action_List.Set_Capacity (26);
- Add_Action (Table.States (203), 4, 1);
- Add_Action (Table.States (203), 5, 2);
- Add_Action (Table.States (203), 13, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (203), 15, 3);
- Add_Action (Table.States (203), 17, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (203), 18, 4);
- Add_Action (Table.States (203), 22, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (203), 24, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (203), 27, 5);
- Add_Action (Table.States (203), 28, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (203), 31, 9);
- Add_Action (Table.States (203), 32, 10);
- Add_Action (Table.States (203), 37, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (203), 41, 13);
- Add_Action (Table.States (203), 43, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (203), 48, 16);
- Add_Action (Table.States (203), 52, 20);
- Add_Action (Table.States (203), 57, 21);
- Add_Action (Table.States (203), 58, 22);
- Add_Action (Table.States (203), 61, 24);
- Add_Action (Table.States (203), 68, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (203), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (203), 93, 31);
- Add_Action (Table.States (203), 104, 360);
- Add_Action (Table.States (203), 105, 33);
- Add_Action (Table.States (203), 106, 34);
- Table.States (203).Goto_List.Set_Capacity (31);
- Add_Goto (Table.States (203), 113, 36);
- Add_Goto (Table.States (203), 123, 38);
- Add_Goto (Table.States (203), 126, 39);
- Add_Goto (Table.States (203), 128, 41);
- Add_Goto (Table.States (203), 131, 42);
- Add_Goto (Table.States (203), 132, 43);
- Add_Goto (Table.States (203), 133, 44);
- Add_Goto (Table.States (203), 139, 47);
- Add_Goto (Table.States (203), 151, 50);
- Add_Goto (Table.States (203), 152, 51);
- Add_Goto (Table.States (203), 161, 53);
- Add_Goto (Table.States (203), 190, 57);
- Add_Goto (Table.States (203), 196, 59);
- Add_Goto (Table.States (203), 217, 68);
- Add_Goto (Table.States (203), 222, 70);
- Add_Goto (Table.States (203), 232, 72);
- Add_Goto (Table.States (203), 239, 73);
- Add_Goto (Table.States (203), 257, 83);
- Add_Goto (Table.States (203), 261, 86);
- Add_Goto (Table.States (203), 272, 92);
- Add_Goto (Table.States (203), 276, 93);
- Add_Goto (Table.States (203), 290, 96);
- Add_Goto (Table.States (203), 293, 97);
- Add_Goto (Table.States (203), 294, 98);
- Add_Goto (Table.States (203), 298, 99);
- Add_Goto (Table.States (203), 299, 361);
- Add_Goto (Table.States (203), 300, 364);
- Add_Goto (Table.States (203), 302, 100);
- Add_Goto (Table.States (203), 303, 101);
- Add_Goto (Table.States (203), 306, 363);
- Add_Goto (Table.States (203), 323, 114);
- Table.States (203).Kernel := To_Vector (((160, 161, 0, False),
(324, 161, 0, False)));
- Table.States (203).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 300, 0)));
- Table.States (204).Action_List.Set_Capacity (2);
- Add_Action (Table.States (204), 22, 365);
- Add_Action (Table.States (204), 43, 366);
- Table.States (204).Kernel := To_Vector (((152, 178, 4, False),
(323, 178, 6, False)));
- Table.States (204).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 22, 365)));
- Table.States (205).Action_List.Set_Capacity (30);
- Add_Action (Table.States (205), 4, 1);
- Add_Action (Table.States (205), 5, 2);
- Add_Action (Table.States (205), 13, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (205), 15, 3);
- Add_Action (Table.States (205), 17, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (205), 18, 4);
- Add_Action (Table.States (205), 22, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (205), 27, 5);
- Add_Action (Table.States (205), 28, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (205), 31, 9);
- Add_Action (Table.States (205), 32, 10);
- Add_Action (Table.States (205), 37, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (205), 41, 13);
- Add_Action (Table.States (205), 43, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (205), 48, 16);
- Add_Action (Table.States (205), 52, 20);
- Add_Action (Table.States (205), 57, 21);
- Add_Action (Table.States (205), 58, 22);
- Add_Action (Table.States (205), 61, 24);
- Add_Action (Table.States (205), 68, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (205), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (205), 76, 235);
- Add_Action (Table.States (205), 84, 237);
- Add_Action (Table.States (205), 93, 31);
- Add_Action (Table.States (205), 96, 238);
- Add_Action (Table.States (205), 101, 239);
- Add_Action (Table.States (205), 102, 240);
- Add_Action (Table.States (205), 104, 360);
- Add_Action (Table.States (205), 105, 33);
- Add_Action (Table.States (205), 106, 34);
- Table.States (205).Goto_List.Set_Capacity (33);
- Add_Goto (Table.States (205), 113, 36);
- Add_Goto (Table.States (205), 115, 241);
- Add_Goto (Table.States (205), 123, 38);
- Add_Goto (Table.States (205), 126, 39);
- Add_Goto (Table.States (205), 128, 41);
- Add_Goto (Table.States (205), 131, 42);
- Add_Goto (Table.States (205), 132, 43);
- Add_Goto (Table.States (205), 133, 44);
- Add_Goto (Table.States (205), 139, 47);
- Add_Goto (Table.States (205), 151, 50);
- Add_Goto (Table.States (205), 152, 51);
- Add_Goto (Table.States (205), 161, 53);
- Add_Goto (Table.States (205), 190, 57);
- Add_Goto (Table.States (205), 196, 59);
- Add_Goto (Table.States (205), 217, 68);
- Add_Goto (Table.States (205), 222, 70);
- Add_Goto (Table.States (205), 232, 72);
- Add_Goto (Table.States (205), 239, 73);
- Add_Goto (Table.States (205), 257, 83);
- Add_Goto (Table.States (205), 261, 86);
- Add_Goto (Table.States (205), 272, 92);
- Add_Goto (Table.States (205), 276, 93);
- Add_Goto (Table.States (205), 290, 96);
- Add_Goto (Table.States (205), 293, 97);
- Add_Goto (Table.States (205), 294, 98);
- Add_Goto (Table.States (205), 298, 99);
- Add_Goto (Table.States (205), 299, 361);
- Add_Goto (Table.States (205), 300, 367);
- Add_Goto (Table.States (205), 302, 100);
- Add_Goto (Table.States (205), 303, 101);
- Add_Goto (Table.States (205), 306, 363);
- Add_Goto (Table.States (205), 322, 242);
- Add_Goto (Table.States (205), 323, 114);
- Table.States (205).Kernel := To_Vector (((128, 239, 2, True),
(178, 239, 0, False), (239, 239, 5, True),
- (239, 239, 2, True), (261, 239, 1, False), (272, 239, 3, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True), (293, 239, 2, True), (324, 239, 0, False)));
- Table.States (205).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 300, 0)));
- Table.States (206).Action_List.Set_Capacity (25);
+ Add_Goto (Table.States (201), 302, 144);
+ Add_Goto (Table.States (201), 321, 145);
+ Add_Goto (Table.States (201), 322, 146);
+ Add_Goto (Table.States (201), 331, 147);
+ Table.States (201).Kernel := To_Vector (((296, 72, 4, False),
(296, 72, 3, False), (296, 72, 3, False)));
+ Table.States (201).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (202).Action_List.Set_Capacity (26);
+ Add_Action (Table.States (202), 4, 1);
+ Add_Action (Table.States (202), 5, 2);
+ Add_Action (Table.States (202), 13, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (202), 15, 3);
+ Add_Action (Table.States (202), 17, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (202), 18, 4);
+ Add_Action (Table.States (202), 22, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (202), 24, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (202), 27, 5);
+ Add_Action (Table.States (202), 28, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (202), 31, 9);
+ Add_Action (Table.States (202), 32, 10);
+ Add_Action (Table.States (202), 37, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (202), 41, 13);
+ Add_Action (Table.States (202), 43, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (202), 48, 16);
+ Add_Action (Table.States (202), 52, 20);
+ Add_Action (Table.States (202), 57, 21);
+ Add_Action (Table.States (202), 58, 22);
+ Add_Action (Table.States (202), 61, 24);
+ Add_Action (Table.States (202), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (202), 79, 31);
+ Add_Action (Table.States (202), 94, 32);
+ Add_Action (Table.States (202), 105, 361);
+ Add_Action (Table.States (202), 106, 34);
+ Add_Action (Table.States (202), 107, 35);
+ Table.States (202).Goto_List.Set_Capacity (31);
+ Add_Goto (Table.States (202), 114, 37);
+ Add_Goto (Table.States (202), 124, 39);
+ Add_Goto (Table.States (202), 127, 40);
+ Add_Goto (Table.States (202), 129, 42);
+ Add_Goto (Table.States (202), 132, 43);
+ Add_Goto (Table.States (202), 133, 44);
+ Add_Goto (Table.States (202), 134, 45);
+ Add_Goto (Table.States (202), 140, 48);
+ Add_Goto (Table.States (202), 152, 51);
+ Add_Goto (Table.States (202), 153, 52);
+ Add_Goto (Table.States (202), 162, 54);
+ Add_Goto (Table.States (202), 191, 58);
+ Add_Goto (Table.States (202), 197, 60);
+ Add_Goto (Table.States (202), 218, 69);
+ Add_Goto (Table.States (202), 223, 71);
+ Add_Goto (Table.States (202), 233, 73);
+ Add_Goto (Table.States (202), 240, 74);
+ Add_Goto (Table.States (202), 258, 84);
+ Add_Goto (Table.States (202), 262, 87);
+ Add_Goto (Table.States (202), 273, 93);
+ Add_Goto (Table.States (202), 277, 94);
+ Add_Goto (Table.States (202), 291, 97);
+ Add_Goto (Table.States (202), 294, 98);
+ Add_Goto (Table.States (202), 295, 99);
+ Add_Goto (Table.States (202), 299, 100);
+ Add_Goto (Table.States (202), 300, 362);
+ Add_Goto (Table.States (202), 301, 363);
+ Add_Goto (Table.States (202), 303, 101);
+ Add_Goto (Table.States (202), 304, 102);
+ Add_Goto (Table.States (202), 307, 364);
+ Add_Goto (Table.States (202), 324, 115);
+ Table.States (202).Kernel := To_Vector ((0 => (296, 114, 0,
False)));
+ Table.States (202).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 301, 0)));
+ Table.States (203).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (203), (22, 24, 43), (296, 5), 1, null,
null);
+ Table.States (203).Kernel := To_Vector ((0 => (296, 161, 0,
False)));
+ Table.States (203).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 296, 1)));
+ Table.States (204).Action_List.Set_Capacity (27);
+ Add_Action (Table.States (204), 4, 1);
+ Add_Action (Table.States (204), 5, 2);
+ Add_Action (Table.States (204), 13, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (204), 15, 3);
+ Add_Action (Table.States (204), 17, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (204), 18, 4);
+ Add_Action (Table.States (204), 22, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (204), 24, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (204), 27, 5);
+ Add_Action (Table.States (204), 28, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (204), 31, 9);
+ Add_Action (Table.States (204), 32, 10);
+ Add_Action (Table.States (204), 37, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (204), 41, 13);
+ Add_Action (Table.States (204), 43, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (204), 48, 16);
+ Add_Action (Table.States (204), 52, 20);
+ Add_Action (Table.States (204), 57, 21);
+ Add_Action (Table.States (204), 58, 22);
+ Add_Action (Table.States (204), 61, 24);
+ Add_Action (Table.States (204), 68, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (204), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (204), 79, 31);
+ Add_Action (Table.States (204), 94, 32);
+ Add_Action (Table.States (204), 105, 361);
+ Add_Action (Table.States (204), 106, 34);
+ Add_Action (Table.States (204), 107, 35);
+ Table.States (204).Goto_List.Set_Capacity (31);
+ Add_Goto (Table.States (204), 114, 37);
+ Add_Goto (Table.States (204), 124, 39);
+ Add_Goto (Table.States (204), 127, 40);
+ Add_Goto (Table.States (204), 129, 42);
+ Add_Goto (Table.States (204), 132, 43);
+ Add_Goto (Table.States (204), 133, 44);
+ Add_Goto (Table.States (204), 134, 45);
+ Add_Goto (Table.States (204), 140, 48);
+ Add_Goto (Table.States (204), 152, 51);
+ Add_Goto (Table.States (204), 153, 52);
+ Add_Goto (Table.States (204), 162, 54);
+ Add_Goto (Table.States (204), 191, 58);
+ Add_Goto (Table.States (204), 197, 60);
+ Add_Goto (Table.States (204), 218, 69);
+ Add_Goto (Table.States (204), 223, 71);
+ Add_Goto (Table.States (204), 233, 73);
+ Add_Goto (Table.States (204), 240, 74);
+ Add_Goto (Table.States (204), 258, 84);
+ Add_Goto (Table.States (204), 262, 87);
+ Add_Goto (Table.States (204), 273, 93);
+ Add_Goto (Table.States (204), 277, 94);
+ Add_Goto (Table.States (204), 291, 97);
+ Add_Goto (Table.States (204), 294, 98);
+ Add_Goto (Table.States (204), 295, 99);
+ Add_Goto (Table.States (204), 299, 100);
+ Add_Goto (Table.States (204), 300, 362);
+ Add_Goto (Table.States (204), 301, 365);
+ Add_Goto (Table.States (204), 303, 101);
+ Add_Goto (Table.States (204), 304, 102);
+ Add_Goto (Table.States (204), 307, 364);
+ Add_Goto (Table.States (204), 324, 115);
+ Table.States (204).Kernel := To_Vector (((161, 162, 0, False),
(325, 162, 0, False)));
+ Table.States (204).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 301, 0)));
+ Table.States (205).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (205), 22, 366);
+ Add_Action (Table.States (205), 43, 367);
+ Table.States (205).Kernel := To_Vector (((153, 179, 4, False),
(324, 179, 6, False)));
+ Table.States (205).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 22, 366)));
+ Table.States (206).Action_List.Set_Capacity (31);
Add_Action (Table.States (206), 4, 1);
Add_Action (Table.States (206), 5, 2);
- Add_Action (Table.States (206), 13, Reduce, (132, 1), 0, null,
null);
+ Add_Action (Table.States (206), 13, Reduce, (133, 1), 0, null,
null);
Add_Action (Table.States (206), 15, 3);
- Add_Action (Table.States (206), 17, Reduce, (132, 1), 0, null,
null);
+ Add_Action (Table.States (206), 17, Reduce, (133, 1), 0, null,
null);
Add_Action (Table.States (206), 18, 4);
- Add_Action (Table.States (206), 22, Reduce, (300, 1), 0, null,
null);
+ Add_Action (Table.States (206), 22, Reduce, (301, 1), 0, null,
null);
Add_Action (Table.States (206), 27, 5);
- Add_Action (Table.States (206), 28, Reduce, (132, 1), 0, null,
null);
+ Add_Action (Table.States (206), 28, Reduce, (133, 1), 0, null,
null);
Add_Action (Table.States (206), 31, 9);
Add_Action (Table.States (206), 32, 10);
- Add_Action (Table.States (206), 37, Reduce, (132, 1), 0, null,
null);
+ Add_Action (Table.States (206), 37, Reduce, (133, 1), 0, null,
null);
Add_Action (Table.States (206), 41, 13);
- Add_Action (Table.States (206), 43, Reduce, (300, 1), 0, null,
null);
+ Add_Action (Table.States (206), 43, Reduce, (301, 1), 0, null,
null);
Add_Action (Table.States (206), 48, 16);
Add_Action (Table.States (206), 52, 20);
Add_Action (Table.States (206), 57, 21);
Add_Action (Table.States (206), 58, 22);
Add_Action (Table.States (206), 61, 24);
- Add_Action (Table.States (206), 68, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (206), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (206), 93, 31);
- Add_Action (Table.States (206), 104, 360);
- Add_Action (Table.States (206), 105, 33);
+ Add_Action (Table.States (206), 68, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (206), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (206), 76, 236);
+ Add_Action (Table.States (206), 79, 31);
+ Add_Action (Table.States (206), 85, 238);
+ Add_Action (Table.States (206), 94, 32);
+ Add_Action (Table.States (206), 97, 239);
+ Add_Action (Table.States (206), 102, 240);
+ Add_Action (Table.States (206), 103, 241);
+ Add_Action (Table.States (206), 105, 361);
Add_Action (Table.States (206), 106, 34);
- Table.States (206).Goto_List.Set_Capacity (31);
- Add_Goto (Table.States (206), 113, 36);
- Add_Goto (Table.States (206), 123, 38);
- Add_Goto (Table.States (206), 126, 39);
- Add_Goto (Table.States (206), 128, 41);
- Add_Goto (Table.States (206), 131, 42);
+ Add_Action (Table.States (206), 107, 35);
+ Table.States (206).Goto_List.Set_Capacity (33);
+ Add_Goto (Table.States (206), 114, 37);
+ Add_Goto (Table.States (206), 116, 242);
+ Add_Goto (Table.States (206), 124, 39);
+ Add_Goto (Table.States (206), 127, 40);
+ Add_Goto (Table.States (206), 129, 42);
Add_Goto (Table.States (206), 132, 43);
Add_Goto (Table.States (206), 133, 44);
- Add_Goto (Table.States (206), 139, 47);
- Add_Goto (Table.States (206), 151, 50);
+ Add_Goto (Table.States (206), 134, 45);
+ Add_Goto (Table.States (206), 140, 48);
Add_Goto (Table.States (206), 152, 51);
- Add_Goto (Table.States (206), 161, 53);
- Add_Goto (Table.States (206), 190, 57);
- Add_Goto (Table.States (206), 196, 59);
- Add_Goto (Table.States (206), 217, 68);
- Add_Goto (Table.States (206), 222, 70);
- Add_Goto (Table.States (206), 232, 72);
- Add_Goto (Table.States (206), 239, 73);
- Add_Goto (Table.States (206), 257, 83);
- Add_Goto (Table.States (206), 261, 86);
- Add_Goto (Table.States (206), 272, 92);
- Add_Goto (Table.States (206), 276, 93);
- Add_Goto (Table.States (206), 290, 96);
- Add_Goto (Table.States (206), 293, 97);
+ Add_Goto (Table.States (206), 153, 52);
+ Add_Goto (Table.States (206), 162, 54);
+ Add_Goto (Table.States (206), 191, 58);
+ Add_Goto (Table.States (206), 197, 60);
+ Add_Goto (Table.States (206), 218, 69);
+ Add_Goto (Table.States (206), 223, 71);
+ Add_Goto (Table.States (206), 233, 73);
+ Add_Goto (Table.States (206), 240, 74);
+ Add_Goto (Table.States (206), 258, 84);
+ Add_Goto (Table.States (206), 262, 87);
+ Add_Goto (Table.States (206), 273, 93);
+ Add_Goto (Table.States (206), 277, 94);
+ Add_Goto (Table.States (206), 291, 97);
Add_Goto (Table.States (206), 294, 98);
- Add_Goto (Table.States (206), 298, 99);
- Add_Goto (Table.States (206), 299, 361);
- Add_Goto (Table.States (206), 300, 368);
- Add_Goto (Table.States (206), 302, 100);
+ Add_Goto (Table.States (206), 295, 99);
+ Add_Goto (Table.States (206), 299, 100);
+ Add_Goto (Table.States (206), 300, 362);
+ Add_Goto (Table.States (206), 301, 368);
Add_Goto (Table.States (206), 303, 101);
- Add_Goto (Table.States (206), 306, 363);
- Add_Goto (Table.States (206), 323, 114);
- Table.States (206).Kernel := To_Vector (((178, 261, 0, False),
(324, 261, 0, False)));
- Table.States (206).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 300, 0)));
- Table.States (207).Action_List.Set_Capacity (3);
- Add_Action (Table.States (207), (22, 24, 43), (296, 1), 1,
select_alternative_list_1'Access, null);
- Table.States (207).Kernel := To_Vector ((0 => (296, 295, 0,
False)));
- Table.States (207).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 296, 1)));
+ Add_Goto (Table.States (206), 304, 102);
+ Add_Goto (Table.States (206), 307, 364);
+ Add_Goto (Table.States (206), 323, 243);
+ Add_Goto (Table.States (206), 324, 115);
+ Table.States (206).Kernel := To_Vector (((129, 240, 2, True),
(179, 240, 0, False), (240, 240, 5, True),
+ (240, 240, 2, True), (262, 240, 1, False), (273, 240, 3, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True), (294, 240, 2, True), (325, 240, 0, False)));
+ Table.States (206).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 301, 0)));
+ Table.States (207).Action_List.Set_Capacity (26);
+ Add_Action (Table.States (207), 4, 1);
+ Add_Action (Table.States (207), 5, 2);
+ Add_Action (Table.States (207), 13, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (207), 15, 3);
+ Add_Action (Table.States (207), 17, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (207), 18, 4);
+ Add_Action (Table.States (207), 22, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (207), 27, 5);
+ Add_Action (Table.States (207), 28, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (207), 31, 9);
+ Add_Action (Table.States (207), 32, 10);
+ Add_Action (Table.States (207), 37, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (207), 41, 13);
+ Add_Action (Table.States (207), 43, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (207), 48, 16);
+ Add_Action (Table.States (207), 52, 20);
+ Add_Action (Table.States (207), 57, 21);
+ Add_Action (Table.States (207), 58, 22);
+ Add_Action (Table.States (207), 61, 24);
+ Add_Action (Table.States (207), 68, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (207), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (207), 79, 31);
+ Add_Action (Table.States (207), 94, 32);
+ Add_Action (Table.States (207), 105, 361);
+ Add_Action (Table.States (207), 106, 34);
+ Add_Action (Table.States (207), 107, 35);
+ Table.States (207).Goto_List.Set_Capacity (31);
+ Add_Goto (Table.States (207), 114, 37);
+ Add_Goto (Table.States (207), 124, 39);
+ Add_Goto (Table.States (207), 127, 40);
+ Add_Goto (Table.States (207), 129, 42);
+ Add_Goto (Table.States (207), 132, 43);
+ Add_Goto (Table.States (207), 133, 44);
+ Add_Goto (Table.States (207), 134, 45);
+ Add_Goto (Table.States (207), 140, 48);
+ Add_Goto (Table.States (207), 152, 51);
+ Add_Goto (Table.States (207), 153, 52);
+ Add_Goto (Table.States (207), 162, 54);
+ Add_Goto (Table.States (207), 191, 58);
+ Add_Goto (Table.States (207), 197, 60);
+ Add_Goto (Table.States (207), 218, 69);
+ Add_Goto (Table.States (207), 223, 71);
+ Add_Goto (Table.States (207), 233, 73);
+ Add_Goto (Table.States (207), 240, 74);
+ Add_Goto (Table.States (207), 258, 84);
+ Add_Goto (Table.States (207), 262, 87);
+ Add_Goto (Table.States (207), 273, 93);
+ Add_Goto (Table.States (207), 277, 94);
+ Add_Goto (Table.States (207), 291, 97);
+ Add_Goto (Table.States (207), 294, 98);
+ Add_Goto (Table.States (207), 295, 99);
+ Add_Goto (Table.States (207), 299, 100);
+ Add_Goto (Table.States (207), 300, 362);
+ Add_Goto (Table.States (207), 301, 369);
+ Add_Goto (Table.States (207), 303, 101);
+ Add_Goto (Table.States (207), 304, 102);
+ Add_Goto (Table.States (207), 307, 364);
+ Add_Goto (Table.States (207), 324, 115);
+ Table.States (207).Kernel := To_Vector (((179, 262, 0, False),
(325, 262, 0, False)));
+ Table.States (207).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 301, 0)));
Table.States (208).Action_List.Set_Capacity (3);
- Add_Action (Table.States (208), 22, Reduce, (297, 0), 1, null,
null);
- Add_Action (Table.States (208), 24, Reduce, (297, 0), 1, null,
null);
- Add_Action (Table.States (208), 43, 369);
- Table.States (208).Kernel := To_Vector (((296, 296, 3, True),
(297, 296, 0, False)));
+ Add_Action (Table.States (208), (22, 24, 43), (297, 1), 1,
select_alternative_list_1'Access, null);
+ Table.States (208).Kernel := To_Vector ((0 => (297, 296, 0,
False)));
Table.States (208).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 297, 1)));
- Table.States (209).Action_List.Set_Capacity (2);
- Add_Action (Table.States (209), 22, 370);
- Add_Action (Table.States (209), 24, 371);
- Table.States (209).Kernel := To_Vector (((294, 297, 4, False),
(294, 297, 3, False)));
- Table.States (209).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 371)));
- Table.States (210).Action_List.Set_Capacity (1);
- Add_Action (Table.States (210), 68, 372);
- Table.States (210).Kernel := To_Vector ((0 => (126, 324, 5,
False)));
- Table.States (210).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 68, 372)));
+ Table.States (209).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (209), 22, Reduce, (298, 0), 1, null,
null);
+ Add_Action (Table.States (209), 24, Reduce, (298, 0), 1, null,
null);
+ Add_Action (Table.States (209), 43, 370);
+ Table.States (209).Kernel := To_Vector (((297, 297, 3, True),
(298, 297, 0, False)));
+ Table.States (209).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 298, 1)));
+ Table.States (210).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (210), 22, 371);
+ Add_Action (Table.States (210), 24, 372);
+ Table.States (210).Kernel := To_Vector (((295, 298, 4, False),
(295, 298, 3, False)));
+ Table.States (210).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 372)));
Table.States (211).Action_List.Set_Capacity (1);
- Add_Action (Table.States (211), 35, 373);
- Table.States (211).Kernel := To_Vector ((0 => (313, 104, 3,
False)));
- Table.States (211).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 373)));
+ Add_Action (Table.States (211), 68, 373);
+ Table.States (211).Kernel := To_Vector ((0 => (127, 325, 5,
False)));
+ Table.States (211).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 68, 373)));
Table.States (212).Action_List.Set_Capacity (1);
- Add_Action (Table.States (212), 104, 374);
- Table.States (212).Kernel := To_Vector (((316, 14, 5, False),
(317, 14, 4, False)));
- Table.States (212).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 374)));
+ Add_Action (Table.States (212), 35, 374);
+ Table.States (212).Kernel := To_Vector ((0 => (314, 105, 3,
False)));
+ Table.States (212).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 374)));
Table.States (213).Action_List.Set_Capacity (1);
- Add_Action (Table.States (213), 104, 375);
- Table.States (213).Kernel := To_Vector (((319, 69, 7, False),
(319, 69, 4, False), (319, 69, 2, False)));
- Table.States (213).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 375)));
- Table.States (214).Action_List.Set_Capacity (3);
- Add_Action (Table.States (214), 35, Reduce, (122, 1), 0, null,
null);
- Add_Action (Table.States (214), 74, 337);
- Add_Action (Table.States (214), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (214).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (214), 122, 376);
- Table.States (214).Kernel := To_Vector (((305, 104, 6, False),
(305, 104, 3, False), (305, 104, 1,
- False)));
- Table.States (214).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
+ Add_Action (Table.States (213), 105, 375);
+ Table.States (213).Kernel := To_Vector (((317, 14, 5, False),
(318, 14, 4, False)));
+ Table.States (213).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 375)));
+ Table.States (214).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (214), 105, 376);
+ Table.States (214).Kernel := To_Vector (((320, 69, 7, False),
(320, 69, 4, False), (320, 69, 2, False)));
+ Table.States (214).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 376)));
Table.States (215).Action_List.Set_Capacity (3);
- Add_Action (Table.States (215), 35, Reduce, (169, 2), 0, null,
null);
- Add_Action (Table.States (215), 76, 377);
- Add_Action (Table.States (215), 96, Reduce, (169, 2), 0, null,
null);
+ Add_Action (Table.States (215), 35, Reduce, (123, 1), 0, null,
null);
+ Add_Action (Table.States (215), 74, 338);
+ Add_Action (Table.States (215), 97, Reduce, (123, 1), 0, null,
null);
Table.States (215).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (215), 169, 378);
- Table.States (215).Kernel := To_Vector (((206, 104, 3, False),
(223, 104, 3, False), (223, 104, 1, False),
- (259, 104, 6, False), (260, 104, 3, False)));
- Table.States (215).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 169, 0)));
- Table.States (216).Action_List.Set_Capacity (1);
- Add_Action (Table.States (216), 69, 379);
- Table.States (216).Kernel := To_Vector ((0 => (331, 9, 3, False)));
- Table.States (216).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 69, 379)));
- Table.States (217).Action_List.Set_Capacity (3);
- Add_Action (Table.States (217), 104, 119);
- Add_Action (Table.States (217), 105, 33);
- Add_Action (Table.States (217), 106, 34);
- Table.States (217).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (217), 128, 41);
- Add_Goto (Table.States (217), 238, 380);
- Add_Goto (Table.States (217), 239, 219);
- Add_Goto (Table.States (217), 272, 92);
- Add_Goto (Table.States (217), 293, 97);
- Table.States (217).Kernel := To_Vector ((0 => (331, 69, 2,
False)));
- Table.States (217).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (218).Action_List.Set_Capacity (2);
- Add_Action (Table.States (218), 83, 381);
- Add_Action (Table.States (218), 96, 382);
- Table.States (218).Kernel := To_Vector (((238, 238, 2, True),
(331, 238, 1, False)));
- Table.States (218).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 382)));
- Table.States (219).Action_List.Set_Capacity (6);
- Add_Action (Table.States (219), 76, 235);
- Add_Action (Table.States (219), 83, Reduce, (238, 1), 1, null,
null);
- Add_Action (Table.States (219), 84, 237);
- Add_Action (Table.States (219), 96, Reduce, (238, 1), 1, null,
null);
- Add_Action (Table.States (219), 101, 239);
- Add_Action (Table.States (219), 102, 240);
- Table.States (219).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (219), 115, 241);
- Add_Goto (Table.States (219), 322, 242);
- Table.States (219).Kernel := To_Vector (((128, 239, 2, True),
(238, 239, 0, False), (239, 239, 5, True),
- (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (219).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 238, 1)));
- Table.States (220).Action_List.Set_Capacity (1);
- Add_Action (Table.States (220), (1 => 37), (229, 0), 2,
iteration_scheme_0'Access, null);
- Table.States (220).Kernel := To_Vector ((0 => (229, 192, 0,
False)));
- Table.States (220).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 229, 2)));
- Table.States (221).Action_List.Set_Capacity (2);
- Add_Action (Table.States (221), 83, 381);
- Add_Action (Table.States (221), 96, 383);
- Table.States (221).Kernel := To_Vector (((238, 238, 2, True),
(332, 238, 1, False)));
- Table.States (221).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 383)));
- Table.States (222).Action_List.Set_Capacity (1);
- Add_Action (Table.States (222), 90, 384);
- Table.States (222).Kernel := To_Vector ((0 => (217, 104, 1,
False)));
- Table.States (222).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 90, 384)));
- Table.States (223).Action_List.Set_Capacity (11);
- Add_Action (Table.States (223), 7, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (223), 13, Reduce, (131, 0), 2,
block_label_0'Access, block_label_0_check'Access);
- Add_Action (Table.States (223), 17, Reduce, (131, 0), 2,
block_label_0'Access, block_label_0_check'Access);
- Add_Action (Table.States (223), 26, 385);
- Add_Action (Table.States (223), 28, Reduce, (131, 0), 2,
block_label_0'Access, block_label_0_check'Access);
- Add_Action (Table.States (223), 37, Reduce, (131, 0), 2,
block_label_0'Access, block_label_0_check'Access);
- Add_Action (Table.States (223), 40, 386);
- Add_Action (Table.States (223), 73, Reduce, (131, 0), 2,
block_label_0'Access, block_label_0_check'Access);
- Add_Action (Table.States (223), 104, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (223), 105, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (223), 106, Reduce, (241, 1), 0, null,
null);
- Table.States (223).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (223), 114, 387);
- Add_Goto (Table.States (223), 241, 388);
- Table.States (223).Kernel := To_Vector (((131, 81, 0, False),
(245, 81, 4, False), (245, 81, 5, False),
- (245, 81, 4, False)));
- Table.States (223).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 131, 2)));
- Table.States (224).Action_List.Set_Capacity (24);
- Add_Action (Table.States (224), 4, 1);
- Add_Action (Table.States (224), 5, 2);
- Add_Action (Table.States (224), 13, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (224), 15, 3);
- Add_Action (Table.States (224), 17, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (224), 18, 4);
- Add_Action (Table.States (224), 24, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (224), 26, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (224), 27, 5);
- Add_Action (Table.States (224), 28, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (224), 31, 9);
- Add_Action (Table.States (224), 32, 10);
- Add_Action (Table.States (224), 37, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (224), 41, 13);
- Add_Action (Table.States (224), 48, 16);
- Add_Action (Table.States (224), 52, 20);
- Add_Action (Table.States (224), 57, 21);
- Add_Action (Table.States (224), 58, 22);
- Add_Action (Table.States (224), 61, 24);
- Add_Action (Table.States (224), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (224), 93, 31);
- Add_Action (Table.States (224), 104, 360);
- Add_Action (Table.States (224), 105, 33);
- Add_Action (Table.States (224), 106, 34);
- Table.States (224).Goto_List.Set_Capacity (32);
- Add_Goto (Table.States (224), 113, 36);
- Add_Goto (Table.States (224), 123, 38);
- Add_Goto (Table.States (224), 126, 39);
- Add_Goto (Table.States (224), 128, 41);
- Add_Goto (Table.States (224), 131, 42);
- Add_Goto (Table.States (224), 132, 43);
- Add_Goto (Table.States (224), 133, 44);
- Add_Goto (Table.States (224), 139, 47);
- Add_Goto (Table.States (224), 151, 50);
- Add_Goto (Table.States (224), 152, 51);
- Add_Goto (Table.States (224), 161, 53);
- Add_Goto (Table.States (224), 190, 57);
- Add_Goto (Table.States (224), 196, 59);
- Add_Goto (Table.States (224), 217, 68);
- Add_Goto (Table.States (224), 218, 389);
- Add_Goto (Table.States (224), 222, 70);
- Add_Goto (Table.States (224), 232, 72);
- Add_Goto (Table.States (224), 239, 73);
- Add_Goto (Table.States (224), 257, 83);
- Add_Goto (Table.States (224), 261, 86);
- Add_Goto (Table.States (224), 272, 92);
- Add_Goto (Table.States (224), 276, 93);
- Add_Goto (Table.States (224), 290, 96);
- Add_Goto (Table.States (224), 293, 97);
- Add_Goto (Table.States (224), 294, 98);
- Add_Goto (Table.States (224), 298, 99);
- Add_Goto (Table.States (224), 299, 361);
- Add_Goto (Table.States (224), 300, 390);
- Add_Goto (Table.States (224), 302, 100);
- Add_Goto (Table.States (224), 303, 101);
- Add_Goto (Table.States (224), 306, 363);
- Add_Goto (Table.States (224), 323, 114);
- Table.States (224).Kernel := To_Vector ((0 => (133, 13, 2,
False)));
- Table.States (224).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 218, 0)));
- Table.States (225).Action_List.Set_Capacity (16);
- Add_Action (Table.States (225), 13, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (225), 25, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (225), 28, 183);
- Add_Action (Table.States (225), 29, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (225), 30, 8);
- Add_Action (Table.States (225), 40, 12);
- Add_Action (Table.States (225), 46, 14);
- Add_Action (Table.States (225), 47, 15);
+ Add_Goto (Table.States (215), 123, 377);
+ Table.States (215).Kernel := To_Vector (((306, 105, 6, False),
(306, 105, 3, False), (306, 105, 1,
+ False)));
+ Table.States (215).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (216).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (216), 35, Reduce, (170, 2), 0, null,
null);
+ Add_Action (Table.States (216), 76, 378);
+ Add_Action (Table.States (216), 97, Reduce, (170, 2), 0, null,
null);
+ Table.States (216).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (216), 170, 379);
+ Table.States (216).Kernel := To_Vector (((207, 105, 3, False),
(224, 105, 3, False), (224, 105, 1, False),
+ (260, 105, 6, False), (261, 105, 3, False)));
+ Table.States (216).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 170, 0)));
+ Table.States (217).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (217), 69, 380);
+ Table.States (217).Kernel := To_Vector ((0 => (332, 9, 3, False)));
+ Table.States (217).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 69, 380)));
+ Table.States (218).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (218), 79, 31);
+ Add_Action (Table.States (218), 105, 120);
+ Add_Action (Table.States (218), 106, 34);
+ Add_Action (Table.States (218), 107, 35);
+ Table.States (218).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (218), 129, 42);
+ Add_Goto (Table.States (218), 239, 381);
+ Add_Goto (Table.States (218), 240, 220);
+ Add_Goto (Table.States (218), 273, 93);
+ Add_Goto (Table.States (218), 294, 98);
+ Table.States (218).Kernel := To_Vector ((0 => (332, 69, 2,
False)));
+ Table.States (218).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (219).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (219), 84, 382);
+ Add_Action (Table.States (219), 97, 383);
+ Table.States (219).Kernel := To_Vector (((239, 239, 2, True),
(332, 239, 1, False)));
+ Table.States (219).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 383)));
+ Table.States (220).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (220), 76, 236);
+ Add_Action (Table.States (220), 84, Reduce, (239, 1), 1, null,
null);
+ Add_Action (Table.States (220), 85, 238);
+ Add_Action (Table.States (220), 97, Reduce, (239, 1), 1, null,
null);
+ Add_Action (Table.States (220), 102, 240);
+ Add_Action (Table.States (220), 103, 241);
+ Table.States (220).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (220), 116, 242);
+ Add_Goto (Table.States (220), 323, 243);
+ Table.States (220).Kernel := To_Vector (((129, 240, 2, True),
(239, 240, 0, False), (240, 240, 5, True),
+ (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (220).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 239, 1)));
+ Table.States (221).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (221), (1 => 37), (230, 0), 2,
iteration_scheme_0'Access, null);
+ Table.States (221).Kernel := To_Vector ((0 => (230, 193, 0,
False)));
+ Table.States (221).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 230, 2)));
+ Table.States (222).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (222), 84, 382);
+ Add_Action (Table.States (222), 97, 384);
+ Table.States (222).Kernel := To_Vector (((239, 239, 2, True),
(333, 239, 1, False)));
+ Table.States (222).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 384)));
+ Table.States (223).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (223), 91, 385);
+ Table.States (223).Kernel := To_Vector ((0 => (218, 105, 1,
False)));
+ Table.States (223).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 91, 385)));
+ Table.States (224).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (224), 7, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (224), 13, Reduce, (132, 0), 2,
block_label_0'Access, block_label_0_check'Access);
+ Add_Action (Table.States (224), 17, Reduce, (132, 0), 2,
block_label_0'Access, block_label_0_check'Access);
+ Add_Action (Table.States (224), 26, 386);
+ Add_Action (Table.States (224), 28, Reduce, (132, 0), 2,
block_label_0'Access, block_label_0_check'Access);
+ Add_Action (Table.States (224), 37, Reduce, (132, 0), 2,
block_label_0'Access, block_label_0_check'Access);
+ Add_Action (Table.States (224), 40, 387);
+ Add_Action (Table.States (224), 73, Reduce, (132, 0), 2,
block_label_0'Access, block_label_0_check'Access);
+ Add_Action (Table.States (224), 79, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (224), 105, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (224), 106, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (224), 107, Reduce, (242, 1), 0, null,
null);
+ Table.States (224).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (224), 115, 388);
+ Add_Goto (Table.States (224), 242, 389);
+ Table.States (224).Kernel := To_Vector (((132, 82, 0, False),
(246, 82, 4, False), (246, 82, 5, False),
+ (246, 82, 4, False)));
+ Table.States (224).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 132, 2)));
+ Table.States (225).Action_List.Set_Capacity (25);
+ Add_Action (Table.States (225), 4, 1);
+ Add_Action (Table.States (225), 5, 2);
+ Add_Action (Table.States (225), 13, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (225), 15, 3);
+ Add_Action (Table.States (225), 17, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (225), 18, 4);
+ Add_Action (Table.States (225), 24, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (225), 26, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (225), 27, 5);
+ Add_Action (Table.States (225), 28, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (225), 31, 9);
+ Add_Action (Table.States (225), 32, 10);
+ Add_Action (Table.States (225), 37, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (225), 41, 13);
Add_Action (Table.States (225), 48, 16);
- Add_Action (Table.States (225), 50, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (225), 51, 19);
- Add_Action (Table.States (225), 63, 25);
- Add_Action (Table.States (225), 66, 26);
- Add_Action (Table.States (225), 69, 27);
- Add_Action (Table.States (225), 71, 28);
- Add_Action (Table.States (225), 104, 185);
- Table.States (225).Goto_List.Set_Capacity (53);
- Add_Goto (Table.States (225), 112, 35);
- Add_Goto (Table.States (225), 121, 37);
+ Add_Action (Table.States (225), 52, 20);
+ Add_Action (Table.States (225), 57, 21);
+ Add_Action (Table.States (225), 58, 22);
+ Add_Action (Table.States (225), 61, 24);
+ Add_Action (Table.States (225), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (225), 79, 31);
+ Add_Action (Table.States (225), 94, 32);
+ Add_Action (Table.States (225), 105, 361);
+ Add_Action (Table.States (225), 106, 34);
+ Add_Action (Table.States (225), 107, 35);
+ Table.States (225).Goto_List.Set_Capacity (32);
+ Add_Goto (Table.States (225), 114, 37);
+ Add_Goto (Table.States (225), 124, 39);
Add_Goto (Table.States (225), 127, 40);
+ Add_Goto (Table.States (225), 129, 42);
+ Add_Goto (Table.States (225), 132, 43);
+ Add_Goto (Table.States (225), 133, 44);
Add_Goto (Table.States (225), 134, 45);
- Add_Goto (Table.States (225), 135, 46);
- Add_Goto (Table.States (225), 157, 391);
- Add_Goto (Table.States (225), 158, 392);
- Add_Goto (Table.States (225), 159, 393);
- Add_Goto (Table.States (225), 179, 54);
- Add_Goto (Table.States (225), 182, 55);
- Add_Goto (Table.States (225), 186, 56);
- Add_Goto (Table.States (225), 193, 58);
- Add_Goto (Table.States (225), 206, 60);
- Add_Goto (Table.States (225), 207, 61);
- Add_Goto (Table.States (225), 209, 62);
- Add_Goto (Table.States (225), 210, 63);
- Add_Goto (Table.States (225), 213, 64);
- Add_Goto (Table.States (225), 214, 65);
- Add_Goto (Table.States (225), 215, 66);
- Add_Goto (Table.States (225), 216, 67);
- Add_Goto (Table.States (225), 219, 69);
+ Add_Goto (Table.States (225), 140, 48);
+ Add_Goto (Table.States (225), 152, 51);
+ Add_Goto (Table.States (225), 153, 52);
+ Add_Goto (Table.States (225), 162, 54);
+ Add_Goto (Table.States (225), 191, 58);
+ Add_Goto (Table.States (225), 197, 60);
+ Add_Goto (Table.States (225), 218, 69);
+ Add_Goto (Table.States (225), 219, 390);
Add_Goto (Table.States (225), 223, 71);
- Add_Goto (Table.States (225), 243, 74);
- Add_Goto (Table.States (225), 244, 75);
- Add_Goto (Table.States (225), 245, 76);
- Add_Goto (Table.States (225), 246, 77);
- Add_Goto (Table.States (225), 247, 78);
- Add_Goto (Table.States (225), 248, 79);
- Add_Goto (Table.States (225), 249, 80);
- Add_Goto (Table.States (225), 250, 81);
- Add_Goto (Table.States (225), 251, 82);
- Add_Goto (Table.States (225), 257, 394);
- Add_Goto (Table.States (225), 259, 84);
- Add_Goto (Table.States (225), 260, 85);
+ Add_Goto (Table.States (225), 233, 73);
+ Add_Goto (Table.States (225), 240, 74);
+ Add_Goto (Table.States (225), 258, 84);
Add_Goto (Table.States (225), 262, 87);
- Add_Goto (Table.States (225), 263, 88);
- Add_Goto (Table.States (225), 264, 89);
- Add_Goto (Table.States (225), 265, 90);
- Add_Goto (Table.States (225), 271, 91);
- Add_Goto (Table.States (225), 281, 94);
- Add_Goto (Table.States (225), 289, 95);
+ Add_Goto (Table.States (225), 273, 93);
+ Add_Goto (Table.States (225), 277, 94);
+ Add_Goto (Table.States (225), 291, 97);
+ Add_Goto (Table.States (225), 294, 98);
+ Add_Goto (Table.States (225), 295, 99);
+ Add_Goto (Table.States (225), 299, 100);
+ Add_Goto (Table.States (225), 300, 362);
+ Add_Goto (Table.States (225), 301, 391);
+ Add_Goto (Table.States (225), 303, 101);
Add_Goto (Table.States (225), 304, 102);
- Add_Goto (Table.States (225), 305, 103);
- Add_Goto (Table.States (225), 307, 105);
- Add_Goto (Table.States (225), 308, 106);
- Add_Goto (Table.States (225), 309, 107);
- Add_Goto (Table.States (225), 311, 108);
- Add_Goto (Table.States (225), 313, 109);
- Add_Goto (Table.States (225), 316, 111);
- Add_Goto (Table.States (225), 317, 112);
- Add_Goto (Table.States (225), 319, 113);
- Add_Goto (Table.States (225), 325, 115);
- Add_Goto (Table.States (225), 331, 116);
- Table.States (225).Kernel := To_Vector ((0 => (133, 17, 3,
False)));
- Table.States (225).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 159, 0)));
- Table.States (226).Action_List.Set_Capacity (2);
- Add_Action (Table.States (226), 37, Reduce, (231, 1), 0, null,
null);
- Add_Action (Table.States (226), 104, 395);
- Table.States (226).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (226), 230, 155);
- Add_Goto (Table.States (226), 231, 156);
- Table.States (226).Kernel := To_Vector ((0 => (229, 28, 0,
False)));
- Table.States (226).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 231, 0)));
- Table.States (227).Action_List.Set_Capacity (23);
- Add_Action (Table.States (227), 4, 1);
- Add_Action (Table.States (227), 5, 2);
- Add_Action (Table.States (227), 13, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (227), 15, 3);
- Add_Action (Table.States (227), 17, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (227), 18, 4);
- Add_Action (Table.States (227), 24, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (227), 27, 5);
- Add_Action (Table.States (227), 28, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (227), 31, 9);
- Add_Action (Table.States (227), 32, 10);
- Add_Action (Table.States (227), 37, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (227), 41, 13);
- Add_Action (Table.States (227), 48, 16);
- Add_Action (Table.States (227), 52, 20);
- Add_Action (Table.States (227), 57, 21);
- Add_Action (Table.States (227), 58, 22);
- Add_Action (Table.States (227), 61, 24);
- Add_Action (Table.States (227), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (227), 93, 31);
- Add_Action (Table.States (227), 104, 360);
- Add_Action (Table.States (227), 105, 33);
- Add_Action (Table.States (227), 106, 34);
- Table.States (227).Goto_List.Set_Capacity (31);
- Add_Goto (Table.States (227), 113, 36);
- Add_Goto (Table.States (227), 123, 38);
- Add_Goto (Table.States (227), 126, 39);
- Add_Goto (Table.States (227), 128, 41);
- Add_Goto (Table.States (227), 131, 42);
- Add_Goto (Table.States (227), 132, 43);
- Add_Goto (Table.States (227), 133, 44);
- Add_Goto (Table.States (227), 139, 47);
- Add_Goto (Table.States (227), 151, 50);
- Add_Goto (Table.States (227), 152, 51);
- Add_Goto (Table.States (227), 161, 53);
- Add_Goto (Table.States (227), 190, 57);
- Add_Goto (Table.States (227), 196, 59);
- Add_Goto (Table.States (227), 217, 68);
- Add_Goto (Table.States (227), 222, 70);
- Add_Goto (Table.States (227), 232, 72);
- Add_Goto (Table.States (227), 239, 73);
- Add_Goto (Table.States (227), 257, 83);
- Add_Goto (Table.States (227), 261, 86);
- Add_Goto (Table.States (227), 272, 92);
- Add_Goto (Table.States (227), 276, 93);
- Add_Goto (Table.States (227), 290, 96);
- Add_Goto (Table.States (227), 293, 97);
- Add_Goto (Table.States (227), 294, 98);
- Add_Goto (Table.States (227), 298, 99);
- Add_Goto (Table.States (227), 299, 361);
- Add_Goto (Table.States (227), 300, 396);
- Add_Goto (Table.States (227), 302, 100);
- Add_Goto (Table.States (227), 303, 101);
- Add_Goto (Table.States (227), 306, 363);
- Add_Goto (Table.States (227), 323, 114);
- Table.States (227).Kernel := To_Vector ((0 => (232, 37, 3,
False)));
- Table.States (227).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 300, 0)));
- Table.States (228).Action_List.Set_Capacity (1);
- Add_Action (Table.States (228), 37, 397);
- Table.States (228).Kernel := To_Vector ((0 => (232, 229, 4,
False)));
- Table.States (228).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 37, 397)));
- Table.States (229).Action_List.Set_Capacity (39);
- Add_Action (Table.States (229), (4, 5, 13, 15, 17, 18, 25, 27, 28,
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
- 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93,
104, 105, 106, 107), (143, 0), 2,
+ Add_Goto (Table.States (225), 307, 364);
+ Add_Goto (Table.States (225), 324, 115);
+ Table.States (225).Kernel := To_Vector ((0 => (134, 13, 2,
False)));
+ Table.States (225).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 219, 0)));
+ Table.States (226).Action_List.Set_Capacity (16);
+ Add_Action (Table.States (226), 13, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (226), 25, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (226), 28, 184);
+ Add_Action (Table.States (226), 29, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (226), 30, 8);
+ Add_Action (Table.States (226), 40, 12);
+ Add_Action (Table.States (226), 46, 14);
+ Add_Action (Table.States (226), 47, 15);
+ Add_Action (Table.States (226), 48, 16);
+ Add_Action (Table.States (226), 50, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (226), 51, 19);
+ Add_Action (Table.States (226), 63, 25);
+ Add_Action (Table.States (226), 66, 26);
+ Add_Action (Table.States (226), 69, 27);
+ Add_Action (Table.States (226), 71, 28);
+ Add_Action (Table.States (226), 105, 186);
+ Table.States (226).Goto_List.Set_Capacity (53);
+ Add_Goto (Table.States (226), 113, 36);
+ Add_Goto (Table.States (226), 122, 38);
+ Add_Goto (Table.States (226), 128, 41);
+ Add_Goto (Table.States (226), 135, 46);
+ Add_Goto (Table.States (226), 136, 47);
+ Add_Goto (Table.States (226), 158, 392);
+ Add_Goto (Table.States (226), 159, 393);
+ Add_Goto (Table.States (226), 160, 394);
+ Add_Goto (Table.States (226), 180, 55);
+ Add_Goto (Table.States (226), 183, 56);
+ Add_Goto (Table.States (226), 187, 57);
+ Add_Goto (Table.States (226), 194, 59);
+ Add_Goto (Table.States (226), 207, 61);
+ Add_Goto (Table.States (226), 208, 62);
+ Add_Goto (Table.States (226), 210, 63);
+ Add_Goto (Table.States (226), 211, 64);
+ Add_Goto (Table.States (226), 214, 65);
+ Add_Goto (Table.States (226), 215, 66);
+ Add_Goto (Table.States (226), 216, 67);
+ Add_Goto (Table.States (226), 217, 68);
+ Add_Goto (Table.States (226), 220, 70);
+ Add_Goto (Table.States (226), 224, 72);
+ Add_Goto (Table.States (226), 244, 75);
+ Add_Goto (Table.States (226), 245, 76);
+ Add_Goto (Table.States (226), 246, 77);
+ Add_Goto (Table.States (226), 247, 78);
+ Add_Goto (Table.States (226), 248, 79);
+ Add_Goto (Table.States (226), 249, 80);
+ Add_Goto (Table.States (226), 250, 81);
+ Add_Goto (Table.States (226), 251, 82);
+ Add_Goto (Table.States (226), 252, 83);
+ Add_Goto (Table.States (226), 258, 395);
+ Add_Goto (Table.States (226), 260, 85);
+ Add_Goto (Table.States (226), 261, 86);
+ Add_Goto (Table.States (226), 263, 88);
+ Add_Goto (Table.States (226), 264, 89);
+ Add_Goto (Table.States (226), 265, 90);
+ Add_Goto (Table.States (226), 266, 91);
+ Add_Goto (Table.States (226), 272, 92);
+ Add_Goto (Table.States (226), 282, 95);
+ Add_Goto (Table.States (226), 290, 96);
+ Add_Goto (Table.States (226), 305, 103);
+ Add_Goto (Table.States (226), 306, 104);
+ Add_Goto (Table.States (226), 308, 106);
+ Add_Goto (Table.States (226), 309, 107);
+ Add_Goto (Table.States (226), 310, 108);
+ Add_Goto (Table.States (226), 312, 109);
+ Add_Goto (Table.States (226), 314, 110);
+ Add_Goto (Table.States (226), 317, 112);
+ Add_Goto (Table.States (226), 318, 113);
+ Add_Goto (Table.States (226), 320, 114);
+ Add_Goto (Table.States (226), 326, 116);
+ Add_Goto (Table.States (226), 332, 117);
+ Table.States (226).Kernel := To_Vector ((0 => (134, 17, 3,
False)));
+ Table.States (226).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 160, 0)));
+ Table.States (227).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (227), 37, Reduce, (232, 1), 0, null,
null);
+ Add_Action (Table.States (227), 105, 396);
+ Table.States (227).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (227), 231, 156);
+ Add_Goto (Table.States (227), 232, 157);
+ Table.States (227).Kernel := To_Vector ((0 => (230, 28, 0,
False)));
+ Table.States (227).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 232, 0)));
+ Table.States (228).Action_List.Set_Capacity (24);
+ Add_Action (Table.States (228), 4, 1);
+ Add_Action (Table.States (228), 5, 2);
+ Add_Action (Table.States (228), 13, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (228), 15, 3);
+ Add_Action (Table.States (228), 17, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (228), 18, 4);
+ Add_Action (Table.States (228), 24, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (228), 27, 5);
+ Add_Action (Table.States (228), 28, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (228), 31, 9);
+ Add_Action (Table.States (228), 32, 10);
+ Add_Action (Table.States (228), 37, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (228), 41, 13);
+ Add_Action (Table.States (228), 48, 16);
+ Add_Action (Table.States (228), 52, 20);
+ Add_Action (Table.States (228), 57, 21);
+ Add_Action (Table.States (228), 58, 22);
+ Add_Action (Table.States (228), 61, 24);
+ Add_Action (Table.States (228), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (228), 79, 31);
+ Add_Action (Table.States (228), 94, 32);
+ Add_Action (Table.States (228), 105, 361);
+ Add_Action (Table.States (228), 106, 34);
+ Add_Action (Table.States (228), 107, 35);
+ Table.States (228).Goto_List.Set_Capacity (31);
+ Add_Goto (Table.States (228), 114, 37);
+ Add_Goto (Table.States (228), 124, 39);
+ Add_Goto (Table.States (228), 127, 40);
+ Add_Goto (Table.States (228), 129, 42);
+ Add_Goto (Table.States (228), 132, 43);
+ Add_Goto (Table.States (228), 133, 44);
+ Add_Goto (Table.States (228), 134, 45);
+ Add_Goto (Table.States (228), 140, 48);
+ Add_Goto (Table.States (228), 152, 51);
+ Add_Goto (Table.States (228), 153, 52);
+ Add_Goto (Table.States (228), 162, 54);
+ Add_Goto (Table.States (228), 191, 58);
+ Add_Goto (Table.States (228), 197, 60);
+ Add_Goto (Table.States (228), 218, 69);
+ Add_Goto (Table.States (228), 223, 71);
+ Add_Goto (Table.States (228), 233, 73);
+ Add_Goto (Table.States (228), 240, 74);
+ Add_Goto (Table.States (228), 258, 84);
+ Add_Goto (Table.States (228), 262, 87);
+ Add_Goto (Table.States (228), 273, 93);
+ Add_Goto (Table.States (228), 277, 94);
+ Add_Goto (Table.States (228), 291, 97);
+ Add_Goto (Table.States (228), 294, 98);
+ Add_Goto (Table.States (228), 295, 99);
+ Add_Goto (Table.States (228), 299, 100);
+ Add_Goto (Table.States (228), 300, 362);
+ Add_Goto (Table.States (228), 301, 397);
+ Add_Goto (Table.States (228), 303, 101);
+ Add_Goto (Table.States (228), 304, 102);
+ Add_Goto (Table.States (228), 307, 364);
+ Add_Goto (Table.States (228), 324, 115);
+ Table.States (228).Kernel := To_Vector ((0 => (233, 37, 3,
False)));
+ Table.States (228).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 301, 0)));
+ Table.States (229).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (229), 37, 398);
+ Table.States (229).Kernel := To_Vector ((0 => (233, 230, 4,
False)));
+ Table.States (229).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 37, 398)));
+ Table.States (230).Action_List.Set_Capacity (40);
+ Add_Action (Table.States (230), (4, 5, 13, 15, 17, 18, 25, 27, 28,
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
+ 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 79,
94, 105, 106, 107, 108), (144, 0), 2,
compilation_unit_list_0'Access, null);
- Table.States (229).Kernel := To_Vector ((0 => (143, 142, 0,
True)));
- Table.States (229).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 143, 2)));
- Table.States (229).Minimal_Complete_Actions_Recursive := True;
- Table.States (230).Action_List.Set_Capacity (3);
- Add_Action (Table.States (230), 104, 119);
- Add_Action (Table.States (230), 105, 33);
- Add_Action (Table.States (230), 106, 34);
- Table.States (230).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (230), 128, 41);
- Add_Goto (Table.States (230), 239, 398);
- Add_Goto (Table.States (230), 272, 92);
- Add_Goto (Table.States (230), 293, 97);
- Table.States (230).Kernel := To_Vector (((251, 47, 4, False),
(251, 47, 3, False)));
- Table.States (230).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (231).Action_List.Set_Capacity (1);
- Add_Action (Table.States (231), 96, 399);
- Table.States (231).Kernel := To_Vector ((0 => (214, 251, 1,
False)));
- Table.States (231).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 399)));
- Table.States (232).Action_List.Set_Capacity (2);
- Add_Action (Table.States (232), 74, 337);
- Add_Action (Table.States (232), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (232).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (232), 122, 400);
- Table.States (232).Kernel := To_Vector ((0 => (216, 312, 1,
False)));
- Table.States (232).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (233).Action_List.Set_Capacity (12);
- Add_Action (Table.States (233), 7, Reduce, (118, 1), 0, null,
null);
- Add_Action (Table.States (233), 8, 401);
- Add_Action (Table.States (233), 11, Reduce, (118, 1), 0, null,
null);
- Add_Action (Table.States (233), 16, 402);
- Add_Conflict (Table.States (233), 16, (118, 1), 0, null, null);
- Add_Action (Table.States (233), 26, 403);
- Add_Action (Table.States (233), 40, Reduce, (118, 1), 0, null,
null);
- Add_Action (Table.States (233), 74, Reduce, (118, 1), 0, null,
null);
- Add_Action (Table.States (233), 82, Reduce, (118, 1), 0, null,
null);
- Add_Action (Table.States (233), 96, Reduce, (118, 1), 0, null,
null);
- Add_Action (Table.States (233), 104, Reduce, (118, 1), 0, null,
null);
- Add_Action (Table.States (233), 105, Reduce, (118, 1), 0, null,
null);
- Add_Action (Table.States (233), 106, Reduce, (118, 1), 0, null,
null);
+ Table.States (230).Kernel := To_Vector ((0 => (144, 143, 0,
True)));
+ Table.States (230).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 144, 2)));
+ Table.States (230).Minimal_Complete_Actions_Recursive := True;
+ Table.States (231).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (231), 79, 31);
+ Add_Action (Table.States (231), 105, 120);
+ Add_Action (Table.States (231), 106, 34);
+ Add_Action (Table.States (231), 107, 35);
+ Table.States (231).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (231), 129, 42);
+ Add_Goto (Table.States (231), 240, 399);
+ Add_Goto (Table.States (231), 273, 93);
+ Add_Goto (Table.States (231), 294, 98);
+ Table.States (231).Kernel := To_Vector (((252, 47, 4, False),
(252, 47, 3, False)));
+ Table.States (231).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (232).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (232), 97, 400);
+ Table.States (232).Kernel := To_Vector ((0 => (215, 252, 1,
False)));
+ Table.States (232).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 400)));
+ Table.States (233).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (233), 74, 338);
+ Add_Action (Table.States (233), 97, Reduce, (123, 1), 0, null,
null);
Table.States (233).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (233), 118, 404);
- Table.States (233).Kernel := To_Vector (((157, 81, 3, False),
(186, 81, 2, False), (244, 81, 3, False),
- (244, 81, 4, False), (244, 81, 10, False), (244, 81, 2, False),
(244, 81, 3, False), (244, 81, 9, False)));
- Table.States (233).Minimal_Complete_Actions := To_Vector (((Shift,
26, 403), (Reduce, 118, 0)));
- Table.States (234).Action_List.Set_Capacity (1);
- Add_Action (Table.States (234), 104, 405);
- Table.States (234).Kernel := To_Vector ((0 => (219, 83, 1, True)));
- Table.States (234).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 405)));
- Table.States (234).Minimal_Complete_Actions_Recursive := True;
- Table.States (235).Action_List.Set_Capacity (20);
- Add_Action (Table.States (235), 3, 121);
- Add_Action (Table.States (235), 15, 258);
- Add_Action (Table.States (235), 28, 259);
- Add_Action (Table.States (235), 32, 260);
- Add_Action (Table.States (235), 39, 122);
- Add_Action (Table.States (235), 40, 261);
- Add_Action (Table.States (235), 41, 124);
- Add_Action (Table.States (235), 44, 263);
- Add_Action (Table.States (235), 52, 125);
- Add_Action (Table.States (235), 76, 126);
- Add_Action (Table.States (235), 77, Reduce, (124, 5), 0, null,
null);
- Add_Action (Table.States (235), 79, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (235), 83, Reduce, (124, 5), 0, null,
null);
- Add_Action (Table.States (235), 87, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (235), 94, 127);
- Add_Action (Table.States (235), 95, 128);
- Add_Action (Table.States (235), 103, 129);
- Add_Action (Table.States (235), 104, 119);
- Add_Action (Table.States (235), 105, 33);
- Add_Action (Table.States (235), 106, 264);
- Table.States (235).Goto_List.Set_Capacity (29);
- Add_Goto (Table.States (235), 117, 130);
- Add_Goto (Table.States (235), 124, 265);
- Add_Goto (Table.States (235), 125, 406);
- Add_Goto (Table.States (235), 128, 41);
- Add_Goto (Table.States (235), 136, 267);
- Add_Goto (Table.States (235), 153, 407);
- Add_Goto (Table.States (235), 165, 269);
- Add_Goto (Table.States (235), 166, 270);
- Add_Goto (Table.States (235), 191, 408);
- Add_Goto (Table.States (235), 197, 133);
- Add_Goto (Table.States (235), 221, 273);
- Add_Goto (Table.States (235), 239, 274);
- Add_Goto (Table.States (235), 258, 135);
- Add_Goto (Table.States (235), 272, 92);
- Add_Goto (Table.States (235), 273, 275);
- Add_Goto (Table.States (235), 275, 136);
- Add_Goto (Table.States (235), 277, 409);
- Add_Goto (Table.States (235), 278, 410);
- Add_Goto (Table.States (235), 282, 137);
- Add_Goto (Table.States (235), 283, 138);
- Add_Goto (Table.States (235), 284, 139);
- Add_Goto (Table.States (235), 285, 140);
- Add_Goto (Table.States (235), 286, 141);
- Add_Goto (Table.States (235), 287, 142);
- Add_Goto (Table.States (235), 293, 97);
- Add_Goto (Table.States (235), 301, 277);
- Add_Goto (Table.States (235), 320, 144);
- Add_Goto (Table.States (235), 321, 145);
- Add_Goto (Table.States (235), 330, 146);
- Table.States (235).Kernel := To_Vector (((115, 76, 1, False),
(115, 76, 3, False), (239, 76, 4, True)));
- Table.States (235).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 125, 0)));
+ Add_Goto (Table.States (233), 123, 401);
+ Table.States (233).Kernel := To_Vector ((0 => (217, 313, 1,
False)));
+ Table.States (233).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (234).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (234), 7, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (234), 8, 402);
+ Add_Action (Table.States (234), 11, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (234), 16, 403);
+ Add_Conflict (Table.States (234), 16, (119, 1), 0, null, null);
+ Add_Action (Table.States (234), 26, 404);
+ Add_Action (Table.States (234), 40, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (234), 74, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (234), 79, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (234), 83, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (234), 97, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (234), 105, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (234), 106, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (234), 107, Reduce, (119, 1), 0, null,
null);
+ Table.States (234).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (234), 119, 405);
+ Table.States (234).Kernel := To_Vector (((158, 82, 3, False),
(187, 82, 2, False), (245, 82, 3, False),
+ (245, 82, 4, False), (245, 82, 10, False), (245, 82, 2, False),
(245, 82, 3, False), (245, 82, 9, False)));
+ Table.States (234).Minimal_Complete_Actions := To_Vector (((Shift,
26, 404), (Reduce, 119, 0)));
+ Table.States (235).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (235), 105, 406);
+ Table.States (235).Kernel := To_Vector ((0 => (220, 84, 1, True)));
+ Table.States (235).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 406)));
Table.States (235).Minimal_Complete_Actions_Recursive := True;
- Table.States (236).Action_List.Set_Capacity (13);
- Add_Action (Table.States (236), 3, 121);
- Add_Action (Table.States (236), 39, 122);
- Add_Action (Table.States (236), 40, 123);
- Add_Action (Table.States (236), 41, 124);
- Add_Action (Table.States (236), 52, 125);
- Add_Action (Table.States (236), 76, 126);
- Add_Action (Table.States (236), 94, 127);
+ Table.States (236).Action_List.Set_Capacity (21);
+ Add_Action (Table.States (236), 3, 122);
+ Add_Action (Table.States (236), 15, 259);
+ Add_Action (Table.States (236), 28, 260);
+ Add_Action (Table.States (236), 32, 261);
+ Add_Action (Table.States (236), 39, 123);
+ Add_Action (Table.States (236), 40, 262);
+ Add_Action (Table.States (236), 41, 125);
+ Add_Action (Table.States (236), 44, 264);
+ Add_Action (Table.States (236), 52, 126);
+ Add_Action (Table.States (236), 76, 127);
+ Add_Action (Table.States (236), 77, Reduce, (125, 6), 0, null,
null);
+ Add_Action (Table.States (236), 79, 31);
+ Add_Action (Table.States (236), 80, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (236), 84, Reduce, (125, 6), 0, null,
null);
+ Add_Action (Table.States (236), 88, Reduce, (167, 2), 0, null,
null);
Add_Action (Table.States (236), 95, 128);
- Add_Action (Table.States (236), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (236), 103, 129);
- Add_Action (Table.States (236), 104, 119);
- Add_Action (Table.States (236), 105, 33);
+ Add_Action (Table.States (236), 96, 129);
+ Add_Action (Table.States (236), 104, 130);
+ Add_Action (Table.States (236), 105, 120);
Add_Action (Table.States (236), 106, 34);
- Table.States (236).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (236), 117, 130);
- Add_Goto (Table.States (236), 128, 41);
- Add_Goto (Table.States (236), 191, 131);
- Add_Goto (Table.States (236), 192, 411);
- Add_Goto (Table.States (236), 197, 133);
- Add_Goto (Table.States (236), 239, 134);
- Add_Goto (Table.States (236), 258, 135);
- Add_Goto (Table.States (236), 272, 92);
- Add_Goto (Table.States (236), 275, 136);
- Add_Goto (Table.States (236), 282, 137);
+ Add_Action (Table.States (236), 107, 265);
+ Table.States (236).Goto_List.Set_Capacity (29);
+ Add_Goto (Table.States (236), 118, 131);
+ Add_Goto (Table.States (236), 125, 266);
+ Add_Goto (Table.States (236), 126, 407);
+ Add_Goto (Table.States (236), 129, 42);
+ Add_Goto (Table.States (236), 137, 268);
+ Add_Goto (Table.States (236), 154, 408);
+ Add_Goto (Table.States (236), 166, 270);
+ Add_Goto (Table.States (236), 167, 271);
+ Add_Goto (Table.States (236), 192, 409);
+ Add_Goto (Table.States (236), 198, 134);
+ Add_Goto (Table.States (236), 222, 274);
+ Add_Goto (Table.States (236), 240, 275);
+ Add_Goto (Table.States (236), 259, 136);
+ Add_Goto (Table.States (236), 273, 93);
+ Add_Goto (Table.States (236), 274, 276);
+ Add_Goto (Table.States (236), 276, 137);
+ Add_Goto (Table.States (236), 278, 410);
+ Add_Goto (Table.States (236), 279, 411);
Add_Goto (Table.States (236), 283, 138);
Add_Goto (Table.States (236), 284, 139);
Add_Goto (Table.States (236), 285, 140);
Add_Goto (Table.States (236), 286, 141);
Add_Goto (Table.States (236), 287, 142);
- Add_Goto (Table.States (236), 293, 97);
- Add_Goto (Table.States (236), 301, 143);
- Add_Goto (Table.States (236), 320, 144);
+ Add_Goto (Table.States (236), 288, 143);
+ Add_Goto (Table.States (236), 294, 98);
+ Add_Goto (Table.States (236), 302, 278);
Add_Goto (Table.States (236), 321, 145);
- Add_Goto (Table.States (236), 330, 146);
- Table.States (236).Kernel := To_Vector ((0 => (123, 82, 1,
False)));
- Table.States (236).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (237).Action_List.Set_Capacity (4);
- Add_Action (Table.States (237), 9, 412);
- Add_Action (Table.States (237), 104, 413);
- Add_Action (Table.States (237), 105, 414);
- Add_Action (Table.States (237), 106, 415);
- Table.States (237).Kernel := To_Vector (((293, 84, 1, True), (293,
84, 1, True), (293, 84, 1, True), (293,
- 84, 1, True)));
- Table.States (237).Minimal_Complete_Actions := To_Vector (((Shift,
104, 413), (Shift, 106, 415), (Shift,
- 105, 414), (Shift, 9, 412)));
- Table.States (237).Minimal_Complete_Actions_Recursive := True;
+ Add_Goto (Table.States (236), 322, 146);
+ Add_Goto (Table.States (236), 331, 147);
+ Table.States (236).Kernel := To_Vector (((116, 76, 1, False),
(116, 76, 3, False), (240, 76, 4, True)));
+ Table.States (236).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 126, 0)));
+ Table.States (236).Minimal_Complete_Actions_Recursive := True;
end Subr_4;
procedure Subr_5
is begin
- Table.States (238).Action_List.Set_Capacity (46);
- Add_Action (Table.States (238), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (261, 0), 2, procedure_call_statement_0'Access, null);
- Table.States (238).Kernel := To_Vector ((0 => (261, 96, 0,
False)));
- Table.States (238).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 261, 2)));
- Table.States (239).Action_List.Set_Capacity (7);
- Add_Action (Table.States (239), (7, 19, 20, 38, 53, 76, 104),
(322, 0), 1, null, null);
- Table.States (239).Kernel := To_Vector ((0 => (322, 101, 0,
False)));
- Table.States (239).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 322, 1)));
+ Table.States (237).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (237), 3, 122);
+ Add_Action (Table.States (237), 39, 123);
+ Add_Action (Table.States (237), 40, 124);
+ Add_Action (Table.States (237), 41, 125);
+ Add_Action (Table.States (237), 52, 126);
+ Add_Action (Table.States (237), 76, 127);
+ Add_Action (Table.States (237), 79, 31);
+ Add_Action (Table.States (237), 95, 128);
+ Add_Action (Table.States (237), 96, 129);
+ Add_Action (Table.States (237), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (237), 104, 130);
+ Add_Action (Table.States (237), 105, 120);
+ Add_Action (Table.States (237), 106, 34);
+ Add_Action (Table.States (237), 107, 35);
+ Table.States (237).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (237), 118, 131);
+ Add_Goto (Table.States (237), 129, 42);
+ Add_Goto (Table.States (237), 192, 132);
+ Add_Goto (Table.States (237), 193, 412);
+ Add_Goto (Table.States (237), 198, 134);
+ Add_Goto (Table.States (237), 240, 135);
+ Add_Goto (Table.States (237), 259, 136);
+ Add_Goto (Table.States (237), 273, 93);
+ Add_Goto (Table.States (237), 276, 137);
+ Add_Goto (Table.States (237), 283, 138);
+ Add_Goto (Table.States (237), 284, 139);
+ Add_Goto (Table.States (237), 285, 140);
+ Add_Goto (Table.States (237), 286, 141);
+ Add_Goto (Table.States (237), 287, 142);
+ Add_Goto (Table.States (237), 288, 143);
+ Add_Goto (Table.States (237), 294, 98);
+ Add_Goto (Table.States (237), 302, 144);
+ Add_Goto (Table.States (237), 321, 145);
+ Add_Goto (Table.States (237), 322, 146);
+ Add_Goto (Table.States (237), 331, 147);
+ Table.States (237).Kernel := To_Vector ((0 => (124, 83, 1,
False)));
+ Table.States (237).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (238).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (238), 9, 413);
+ Add_Action (Table.States (238), 105, 414);
+ Add_Action (Table.States (238), 106, 415);
+ Add_Action (Table.States (238), 107, 416);
+ Table.States (238).Kernel := To_Vector (((294, 85, 1, True), (294,
85, 1, True), (294, 85, 1, True), (294,
+ 85, 1, True)));
+ Table.States (238).Minimal_Complete_Actions := To_Vector (((Shift,
105, 414), (Shift, 107, 416), (Shift,
+ 106, 415), (Shift, 9, 413)));
+ Table.States (238).Minimal_Complete_Actions_Recursive := True;
+ Table.States (239).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (239), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (262, 0), 2, procedure_call_statement_0'Access, null);
+ Table.States (239).Kernel := To_Vector ((0 => (262, 97, 0,
False)));
+ Table.States (239).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 262, 2)));
Table.States (240).Action_List.Set_Capacity (7);
- Add_Action (Table.States (240), (7, 19, 20, 38, 53, 76, 104),
(322, 1), 1, null, null);
- Table.States (240).Kernel := To_Vector ((0 => (322, 102, 0,
False)));
- Table.States (240).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 322, 1)));
- Table.States (241).Action_List.Set_Capacity (63);
- Add_Action (Table.States (241), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
- 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
- 88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104,
105, 106), (239, 1), 2, name_1'Access,
+ Add_Action (Table.States (240), (7, 19, 20, 38, 53, 76, 105),
(323, 0), 1, null, null);
+ Table.States (240).Kernel := To_Vector ((0 => (323, 102, 0,
False)));
+ Table.States (240).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 323, 1)));
+ Table.States (241).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (241), (7, 19, 20, 38, 53, 76, 105),
(323, 1), 1, null, null);
+ Table.States (241).Kernel := To_Vector ((0 => (323, 103, 0,
False)));
+ Table.States (241).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 323, 1)));
+ Table.States (242).Action_List.Set_Capacity (64);
+ Add_Action (Table.States (242), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+ 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
105, 106, 107), (240, 1), 2, name_1'Access,
null);
- Table.States (241).Kernel := To_Vector ((0 => (239, 115, 0,
True)));
- Table.States (241).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 239, 2)));
- Table.States (241).Minimal_Complete_Actions_Recursive := True;
- Table.States (242).Action_List.Set_Capacity (6);
- Add_Action (Table.States (242), 7, 416);
- Add_Action (Table.States (242), 19, 417);
- Add_Action (Table.States (242), 20, 418);
- Add_Action (Table.States (242), 38, 419);
- Add_Action (Table.States (242), 76, 126);
- Add_Action (Table.States (242), 104, 420);
- Table.States (242).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (242), 117, 421);
- Add_Goto (Table.States (242), 129, 422);
- Table.States (242).Kernel := To_Vector (((128, 322, 1, True),
(272, 322, 2, True)));
- Table.States (242).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 420)));
+ Table.States (242).Kernel := To_Vector ((0 => (240, 116, 0,
True)));
+ Table.States (242).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 240, 2)));
Table.States (242).Minimal_Complete_Actions_Recursive := True;
- Table.States (243).Action_List.Set_Capacity (1);
- Add_Action (Table.States (243), 104, 423);
- Table.States (243).Kernel := To_Vector (((179, 25, 5, False),
(179, 25, 2, False)));
- Table.States (243).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 423)));
- Table.States (244).Action_List.Set_Capacity (3);
- Add_Action (Table.States (244), 104, 119);
- Add_Action (Table.States (244), 105, 33);
- Add_Action (Table.States (244), 106, 34);
- Table.States (244).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (244), 128, 41);
- Add_Goto (Table.States (244), 239, 424);
- Add_Goto (Table.States (244), 272, 92);
- Add_Goto (Table.States (244), 293, 97);
- Table.States (244).Kernel := To_Vector (((207, 29, 2, False),
(213, 29, 5, False)));
- Table.States (244).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (245).Action_List.Set_Capacity (3);
- Add_Action (Table.States (245), 104, 119);
- Add_Action (Table.States (245), 105, 33);
+ Table.States (243).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (243), 7, 417);
+ Add_Action (Table.States (243), 19, 418);
+ Add_Action (Table.States (243), 20, 419);
+ Add_Action (Table.States (243), 38, 420);
+ Add_Action (Table.States (243), 76, 127);
+ Add_Action (Table.States (243), 105, 421);
+ Table.States (243).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (243), 118, 422);
+ Add_Goto (Table.States (243), 130, 423);
+ Table.States (243).Kernel := To_Vector (((129, 323, 1, True),
(273, 323, 2, True)));
+ Table.States (243).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 421)));
+ Table.States (243).Minimal_Complete_Actions_Recursive := True;
+ Table.States (244).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (244), 105, 424);
+ Table.States (244).Kernel := To_Vector (((180, 25, 5, False),
(180, 25, 2, False)));
+ Table.States (244).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 424)));
+ Table.States (245).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (245), 79, 31);
+ Add_Action (Table.States (245), 105, 120);
Add_Action (Table.States (245), 106, 34);
+ Add_Action (Table.States (245), 107, 35);
Table.States (245).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (245), 128, 41);
- Add_Goto (Table.States (245), 239, 425);
- Add_Goto (Table.States (245), 272, 92);
- Add_Goto (Table.States (245), 293, 97);
- Table.States (245).Kernel := To_Vector (((213, 50, 5, False),
(262, 50, 1, False)));
- Table.States (245).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
+ Add_Goto (Table.States (245), 129, 42);
+ Add_Goto (Table.States (245), 240, 425);
+ Add_Goto (Table.States (245), 273, 93);
+ Add_Goto (Table.States (245), 294, 98);
+ Table.States (245).Kernel := To_Vector (((208, 29, 2, False),
(214, 29, 5, False)));
+ Table.States (245).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
Table.States (246).Action_List.Set_Capacity (4);
- Add_Action (Table.States (246), 35, 426);
- Add_Conflict (Table.States (246), 35, (312, 1), 1, null,
subprogram_specification_1_check'Access);
- Add_Action (Table.States (246), 56, Reduce, (312, 1), 1, null,
subprogram_specification_1_check'Access);
- Add_Action (Table.States (246), 74, Reduce, (312, 1), 1, null,
subprogram_specification_1_check'Access);
- Add_Action (Table.States (246), 96, Reduce, (312, 1), 1, null,
subprogram_specification_1_check'Access);
- Table.States (246).Kernel := To_Vector (((193, 207, 4, False),
(312, 207, 0, False)));
- Table.States (246).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 312, 1)));
+ Add_Action (Table.States (246), 79, 31);
+ Add_Action (Table.States (246), 105, 120);
+ Add_Action (Table.States (246), 106, 34);
+ Add_Action (Table.States (246), 107, 35);
+ Table.States (246).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (246), 129, 42);
+ Add_Goto (Table.States (246), 240, 426);
+ Add_Goto (Table.States (246), 273, 93);
+ Add_Goto (Table.States (246), 294, 98);
+ Table.States (246).Kernel := To_Vector (((214, 50, 5, False),
(263, 50, 1, False)));
+ Table.States (246).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
Table.States (247).Action_List.Set_Capacity (4);
Add_Action (Table.States (247), 35, 427);
- Add_Conflict (Table.States (247), 35, (312, 0), 1, null,
subprogram_specification_0_check'Access);
- Add_Action (Table.States (247), 56, Reduce, (312, 0), 1, null,
subprogram_specification_0_check'Access);
- Add_Action (Table.States (247), 74, Reduce, (312, 0), 1, null,
subprogram_specification_0_check'Access);
- Add_Action (Table.States (247), 96, Reduce, (312, 0), 1, null,
subprogram_specification_0_check'Access);
- Table.States (247).Kernel := To_Vector (((243, 262, 3, False),
(312, 262, 0, False)));
- Table.States (247).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 312, 1)));
+ Add_Conflict (Table.States (247), 35, (313, 1), 1, null,
subprogram_specification_1_check'Access);
+ Add_Action (Table.States (247), 56, Reduce, (313, 1), 1, null,
subprogram_specification_1_check'Access);
+ Add_Action (Table.States (247), 74, Reduce, (313, 1), 1, null,
subprogram_specification_1_check'Access);
+ Add_Action (Table.States (247), 97, Reduce, (313, 1), 1, null,
subprogram_specification_1_check'Access);
+ Table.States (247).Kernel := To_Vector (((194, 208, 4, False),
(313, 208, 0, False)));
+ Table.States (247).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 313, 1)));
Table.States (248).Action_List.Set_Capacity (4);
Add_Action (Table.States (248), 35, 428);
- Add_Conflict (Table.States (248), 35, (122, 1), 0, null, null);
- Add_Action (Table.States (248), 56, 429);
- Add_Action (Table.States (248), 74, 337);
- Add_Action (Table.States (248), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (248).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (248), 122, 430);
- Table.States (248).Kernel := To_Vector (((112, 312, 3, False),
(307, 312, 4, False), (308, 312, 3, False),
- (309, 312, 1, False), (311, 312, 3, False)));
- Table.States (248).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (249).Action_List.Set_Capacity (40);
- Add_Action (Table.States (249), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (249, 0), 2,
+ Add_Conflict (Table.States (248), 35, (313, 0), 1, null,
subprogram_specification_0_check'Access);
+ Add_Action (Table.States (248), 56, Reduce, (313, 0), 1, null,
subprogram_specification_0_check'Access);
+ Add_Action (Table.States (248), 74, Reduce, (313, 0), 1, null,
subprogram_specification_0_check'Access);
+ Add_Action (Table.States (248), 97, Reduce, (313, 0), 1, null,
subprogram_specification_0_check'Access);
+ Table.States (248).Kernel := To_Vector (((244, 263, 3, False),
(313, 263, 0, False)));
+ Table.States (248).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 313, 1)));
+ Table.States (249).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (249), 35, 429);
+ Add_Conflict (Table.States (249), 35, (123, 1), 0, null, null);
+ Add_Action (Table.States (249), 56, 430);
+ Add_Action (Table.States (249), 74, 338);
+ Add_Action (Table.States (249), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (249).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (249), 123, 431);
+ Table.States (249).Kernel := To_Vector (((113, 313, 3, False),
(308, 313, 4, False), (309, 313, 3, False),
+ (310, 313, 1, False), (312, 313, 3, False)));
+ Table.States (249).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (250).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (250), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (250, 0), 2,
package_declaration_0'Access, null);
- Table.States (249).Kernel := To_Vector ((0 => (249, 96, 0,
False)));
- Table.States (249).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 249, 2)));
- Table.States (250).Action_List.Set_Capacity (20);
- Add_Action (Table.States (250), 3, 121);
- Add_Action (Table.States (250), 15, 258);
- Add_Action (Table.States (250), 28, 259);
- Add_Action (Table.States (250), 32, 260);
- Add_Action (Table.States (250), 39, 122);
- Add_Action (Table.States (250), 40, 261);
- Add_Action (Table.States (250), 41, 124);
- Add_Action (Table.States (250), 44, 263);
- Add_Action (Table.States (250), 52, 125);
- Add_Action (Table.States (250), 76, 126);
- Add_Action (Table.States (250), 77, Reduce, (124, 5), 0, null,
null);
- Add_Action (Table.States (250), 79, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (250), 83, Reduce, (124, 5), 0, null,
null);
- Add_Action (Table.States (250), 87, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (250), 94, 127);
- Add_Action (Table.States (250), 95, 128);
- Add_Action (Table.States (250), 103, 129);
- Add_Action (Table.States (250), 104, 119);
- Add_Action (Table.States (250), 105, 33);
- Add_Action (Table.States (250), 106, 264);
- Table.States (250).Goto_List.Set_Capacity (28);
- Add_Goto (Table.States (250), 117, 130);
- Add_Goto (Table.States (250), 124, 265);
- Add_Goto (Table.States (250), 125, 406);
- Add_Goto (Table.States (250), 128, 41);
- Add_Goto (Table.States (250), 136, 267);
- Add_Goto (Table.States (250), 153, 407);
- Add_Goto (Table.States (250), 165, 269);
- Add_Goto (Table.States (250), 166, 270);
- Add_Goto (Table.States (250), 191, 408);
- Add_Goto (Table.States (250), 197, 133);
- Add_Goto (Table.States (250), 221, 273);
- Add_Goto (Table.States (250), 239, 274);
- Add_Goto (Table.States (250), 258, 135);
- Add_Goto (Table.States (250), 272, 92);
- Add_Goto (Table.States (250), 273, 275);
- Add_Goto (Table.States (250), 275, 136);
- Add_Goto (Table.States (250), 277, 276);
- Add_Goto (Table.States (250), 282, 137);
- Add_Goto (Table.States (250), 283, 138);
- Add_Goto (Table.States (250), 284, 139);
- Add_Goto (Table.States (250), 285, 140);
- Add_Goto (Table.States (250), 286, 141);
- Add_Goto (Table.States (250), 287, 142);
- Add_Goto (Table.States (250), 293, 97);
- Add_Goto (Table.States (250), 301, 277);
- Add_Goto (Table.States (250), 320, 144);
- Add_Goto (Table.States (250), 321, 145);
- Add_Goto (Table.States (250), 330, 146);
- Table.States (250).Kernel := To_Vector (((115, 76, 1, False),
(115, 76, 3, False)));
- Table.States (250).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 125, 0)));
- Table.States (251).Action_List.Set_Capacity (3);
- Add_Action (Table.States (251), (21, 76, 96), (116, 0), 1, null,
null);
- Table.States (251).Kernel := To_Vector ((0 => (116, 115, 0,
False)));
- Table.States (251).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 116, 1)));
+ Table.States (250).Kernel := To_Vector ((0 => (250, 97, 0,
False)));
+ Table.States (250).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 250, 2)));
+ Table.States (251).Action_List.Set_Capacity (21);
+ Add_Action (Table.States (251), 3, 122);
+ Add_Action (Table.States (251), 15, 259);
+ Add_Action (Table.States (251), 28, 260);
+ Add_Action (Table.States (251), 32, 261);
+ Add_Action (Table.States (251), 39, 123);
+ Add_Action (Table.States (251), 40, 262);
+ Add_Action (Table.States (251), 41, 125);
+ Add_Action (Table.States (251), 44, 264);
+ Add_Action (Table.States (251), 52, 126);
+ Add_Action (Table.States (251), 76, 127);
+ Add_Action (Table.States (251), 77, Reduce, (125, 6), 0, null,
null);
+ Add_Action (Table.States (251), 79, 31);
+ Add_Action (Table.States (251), 80, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (251), 84, Reduce, (125, 6), 0, null,
null);
+ Add_Action (Table.States (251), 88, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (251), 95, 128);
+ Add_Action (Table.States (251), 96, 129);
+ Add_Action (Table.States (251), 104, 130);
+ Add_Action (Table.States (251), 105, 120);
+ Add_Action (Table.States (251), 106, 34);
+ Add_Action (Table.States (251), 107, 265);
+ Table.States (251).Goto_List.Set_Capacity (28);
+ Add_Goto (Table.States (251), 118, 131);
+ Add_Goto (Table.States (251), 125, 266);
+ Add_Goto (Table.States (251), 126, 407);
+ Add_Goto (Table.States (251), 129, 42);
+ Add_Goto (Table.States (251), 137, 268);
+ Add_Goto (Table.States (251), 154, 408);
+ Add_Goto (Table.States (251), 166, 270);
+ Add_Goto (Table.States (251), 167, 271);
+ Add_Goto (Table.States (251), 192, 409);
+ Add_Goto (Table.States (251), 198, 134);
+ Add_Goto (Table.States (251), 222, 274);
+ Add_Goto (Table.States (251), 240, 275);
+ Add_Goto (Table.States (251), 259, 136);
+ Add_Goto (Table.States (251), 273, 93);
+ Add_Goto (Table.States (251), 274, 276);
+ Add_Goto (Table.States (251), 276, 137);
+ Add_Goto (Table.States (251), 278, 277);
+ Add_Goto (Table.States (251), 283, 138);
+ Add_Goto (Table.States (251), 284, 139);
+ Add_Goto (Table.States (251), 285, 140);
+ Add_Goto (Table.States (251), 286, 141);
+ Add_Goto (Table.States (251), 287, 142);
+ Add_Goto (Table.States (251), 288, 143);
+ Add_Goto (Table.States (251), 294, 98);
+ Add_Goto (Table.States (251), 302, 278);
+ Add_Goto (Table.States (251), 321, 145);
+ Add_Goto (Table.States (251), 322, 146);
+ Add_Goto (Table.States (251), 331, 147);
+ Table.States (251).Kernel := To_Vector (((116, 76, 1, False),
(116, 76, 3, False)));
+ Table.States (251).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 126, 0)));
Table.States (252).Action_List.Set_Capacity (3);
- Add_Action (Table.States (252), 21, Reduce, (253, 1), 0, null,
null);
- Add_Action (Table.States (252), 76, 431);
- Add_Action (Table.States (252), 96, Reduce, (253, 1), 0, null,
null);
- Table.States (252).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (252), 199, 344);
- Add_Goto (Table.States (252), 253, 432);
- Table.States (252).Kernel := To_Vector (((113, 116, 3, False),
(113, 116, 1, False)));
- Table.States (252).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 253, 0)));
- Table.States (253).Action_List.Set_Capacity (46);
- Add_Action (Table.States (253), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (303, 8), 3, simple_statement_8'Access, null);
- Table.States (253).Kernel := To_Vector ((0 => (303, 96, 0,
False)));
- Table.States (253).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 303, 3)));
- Table.States (254).Action_List.Set_Capacity (35);
- Add_Action (Table.States (254), (10, 20, 21, 22, 23, 33, 35, 37,
38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
- 78, 79, 82, 83, 85, 86, 87, 88, 89, 91, 92, 94, 95, 96, 97, 98,
99), (197, 2), 2, null, null);
- Table.States (254).Kernel := To_Vector ((0 => (197, 258, 0,
False)));
- Table.States (254).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 197, 2)));
- Table.States (255).Action_List.Set_Capacity (40);
- Add_Action (Table.States (255), 10, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 20, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 21, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 22, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 23, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 33, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 35, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 37, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 38, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 40, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 42, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 43, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 53, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 55, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 68, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 74, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 75, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 76, 235);
- Add_Action (Table.States (255), 77, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 78, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 79, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 82, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 83, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 84, 237);
- Add_Action (Table.States (255), 85, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 86, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 87, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 88, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 89, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 91, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 92, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 94, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 95, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 96, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 97, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 98, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 99, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 100, Reduce, (258, 4), 2,
primary_4'Access, null);
- Add_Action (Table.States (255), 101, 239);
- Add_Action (Table.States (255), 102, 240);
- Table.States (255).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (255), 115, 241);
- Add_Goto (Table.States (255), 322, 242);
- Table.States (255).Kernel := To_Vector (((128, 239, 2, True),
(239, 239, 5, True), (239, 239, 2, True),
- (258, 239, 0, False), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (255).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 258, 2)));
- Table.States (256).Action_List.Set_Capacity (35);
- Add_Action (Table.States (256), (10, 20, 21, 22, 23, 33, 35, 37,
38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
- 78, 79, 82, 83, 85, 86, 87, 88, 89, 91, 92, 94, 95, 96, 97, 98,
99), (197, 3), 2, null, null);
- Table.States (256).Kernel := To_Vector ((0 => (197, 258, 0,
False)));
- Table.States (256).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 197, 2)));
- Table.States (257).Action_List.Set_Capacity (21);
- Add_Action (Table.States (257), 10, Reduce, (275, 1), 2, null,
null);
- Add_Action (Table.States (257), 20, Reduce, (275, 1), 2, null,
null);
- Add_Action (Table.States (257), 21, Reduce, (275, 1), 2, null,
null);
- Add_Action (Table.States (257), 22, Reduce, (275, 1), 2, null,
null);
- Add_Action (Table.States (257), 23, Reduce, (275, 1), 2, null,
null);
- Add_Action (Table.States (257), 35, Reduce, (275, 1), 2, null,
null);
- Add_Action (Table.States (257), 37, Reduce, (275, 1), 2, null,
null);
- Add_Action (Table.States (257), 43, Reduce, (275, 1), 2, null,
null);
- Add_Action (Table.States (257), 53, Reduce, (275, 1), 2, null,
null);
- Add_Action (Table.States (257), 68, Reduce, (275, 1), 2, null,
null);
- Add_Action (Table.States (257), 74, 433);
- Add_Conflict (Table.States (257), 74, (275, 1), 2, null, null);
- Add_Action (Table.States (257), 75, Reduce, (275, 1), 2, null,
null);
- Add_Action (Table.States (257), 76, 235);
- Add_Action (Table.States (257), 77, Reduce, (275, 1), 2, null,
null);
- Add_Action (Table.States (257), 79, Reduce, (275, 1), 2, null,
null);
- Add_Action (Table.States (257), 83, Reduce, (275, 1), 2, null,
null);
- Add_Action (Table.States (257), 84, 237);
- Add_Action (Table.States (257), 87, Reduce, (275, 1), 2, null,
null);
- Add_Action (Table.States (257), 96, Reduce, (275, 1), 2, null,
null);
- Add_Action (Table.States (257), 101, 239);
- Add_Action (Table.States (257), 102, 240);
- Table.States (257).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (257), 115, 241);
- Add_Goto (Table.States (257), 322, 242);
- Table.States (257).Kernel := To_Vector (((128, 239, 2, True),
(239, 239, 5, True), (239, 239, 2, True),
- (272, 239, 3, True), (275, 239, 1, True), (275, 239, 0, False),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True), (293, 239, 2, True)));
- Table.States (257).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 275, 2)));
- Table.States (257).Minimal_Complete_Actions_Recursive := True;
- Table.States (258).Action_List.Set_Capacity (13);
- Add_Action (Table.States (258), 3, 121);
- Add_Action (Table.States (258), 35, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (258), 39, 122);
- Add_Action (Table.States (258), 40, 123);
- Add_Action (Table.States (258), 41, 124);
- Add_Action (Table.States (258), 52, 125);
- Add_Action (Table.States (258), 76, 126);
- Add_Action (Table.States (258), 94, 127);
- Add_Action (Table.States (258), 95, 128);
- Add_Action (Table.States (258), 103, 129);
- Add_Action (Table.States (258), 104, 119);
- Add_Action (Table.States (258), 105, 33);
- Add_Action (Table.States (258), 106, 34);
- Table.States (258).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (258), 117, 130);
- Add_Goto (Table.States (258), 128, 41);
- Add_Goto (Table.States (258), 191, 131);
- Add_Goto (Table.States (258), 192, 434);
- Add_Goto (Table.States (258), 197, 133);
- Add_Goto (Table.States (258), 239, 134);
- Add_Goto (Table.States (258), 258, 135);
- Add_Goto (Table.States (258), 272, 92);
- Add_Goto (Table.States (258), 275, 136);
- Add_Goto (Table.States (258), 282, 137);
- Add_Goto (Table.States (258), 283, 138);
- Add_Goto (Table.States (258), 284, 139);
- Add_Goto (Table.States (258), 285, 140);
- Add_Goto (Table.States (258), 286, 141);
- Add_Goto (Table.States (258), 287, 142);
- Add_Goto (Table.States (258), 293, 97);
- Add_Goto (Table.States (258), 301, 143);
- Add_Goto (Table.States (258), 320, 144);
- Add_Goto (Table.States (258), 321, 145);
- Add_Goto (Table.States (258), 330, 146);
- Table.States (258).Kernel := To_Vector ((0 => (136, 15, 3,
False)));
- Table.States (258).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (259).Action_List.Set_Capacity (2);
- Add_Action (Table.States (259), 9, 435);
- Add_Action (Table.States (259), 62, 436);
- Table.States (259).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (259), 274, 437);
- Table.States (259).Kernel := To_Vector ((0 => (273, 28, 5,
False)));
- Table.States (259).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 9, 435)));
- Table.States (260).Action_List.Set_Capacity (13);
- Add_Action (Table.States (260), 3, 121);
- Add_Action (Table.States (260), 39, 122);
- Add_Action (Table.States (260), 40, 123);
- Add_Action (Table.States (260), 41, 124);
- Add_Action (Table.States (260), 52, 125);
- Add_Action (Table.States (260), 68, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (260), 76, 126);
- Add_Action (Table.States (260), 94, 127);
- Add_Action (Table.States (260), 95, 128);
- Add_Action (Table.States (260), 103, 129);
- Add_Action (Table.States (260), 104, 119);
- Add_Action (Table.States (260), 105, 33);
- Add_Action (Table.States (260), 106, 34);
- Table.States (260).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (260), 117, 130);
- Add_Goto (Table.States (260), 128, 41);
- Add_Goto (Table.States (260), 191, 131);
- Add_Goto (Table.States (260), 192, 438);
- Add_Goto (Table.States (260), 197, 133);
- Add_Goto (Table.States (260), 239, 134);
- Add_Goto (Table.States (260), 258, 135);
- Add_Goto (Table.States (260), 272, 92);
- Add_Goto (Table.States (260), 275, 136);
- Add_Goto (Table.States (260), 282, 137);
- Add_Goto (Table.States (260), 283, 138);
- Add_Goto (Table.States (260), 284, 139);
- Add_Goto (Table.States (260), 285, 140);
- Add_Goto (Table.States (260), 286, 141);
- Add_Goto (Table.States (260), 287, 142);
- Add_Goto (Table.States (260), 293, 97);
- Add_Goto (Table.States (260), 301, 143);
- Add_Goto (Table.States (260), 320, 144);
- Add_Goto (Table.States (260), 321, 145);
- Add_Goto (Table.States (260), 330, 146);
- Table.States (260).Kernel := To_Vector (((221, 32, 4, False),
(221, 32, 2, False), (221, 32, 3, False),
- (221, 32, 1, False)));
- Table.States (260).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (261).Action_List.Set_Capacity (7);
- Add_Action (Table.States (261), 39, 122);
- Add_Action (Table.States (261), 41, 439);
- Add_Action (Table.States (261), 76, 126);
- Add_Action (Table.States (261), 103, 129);
- Add_Action (Table.States (261), 104, 119);
- Add_Action (Table.States (261), 105, 33);
+ Add_Action (Table.States (252), (21, 76, 97), (117, 0), 1, null,
null);
+ Table.States (252).Kernel := To_Vector ((0 => (117, 116, 0,
False)));
+ Table.States (252).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 117, 1)));
+ Table.States (253).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (253), 21, Reduce, (254, 1), 0, null,
null);
+ Add_Action (Table.States (253), 76, 432);
+ Add_Action (Table.States (253), 97, Reduce, (254, 1), 0, null,
null);
+ Table.States (253).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (253), 200, 345);
+ Add_Goto (Table.States (253), 254, 433);
+ Table.States (253).Kernel := To_Vector (((114, 117, 3, False),
(114, 117, 1, False)));
+ Table.States (253).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 254, 0)));
+ Table.States (254).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (254), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (304, 8), 3, simple_statement_8'Access, null);
+ Table.States (254).Kernel := To_Vector ((0 => (304, 97, 0,
False)));
+ Table.States (254).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 304, 3)));
+ Table.States (255).Action_List.Set_Capacity (35);
+ Add_Action (Table.States (255), (10, 20, 21, 22, 23, 33, 35, 37,
38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
+ 78, 80, 83, 84, 86, 87, 88, 89, 90, 92, 93, 95, 96, 97, 98, 99,
100), (198, 2), 2, null, null);
+ Table.States (255).Kernel := To_Vector ((0 => (198, 259, 0,
False)));
+ Table.States (255).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 198, 2)));
+ Table.States (256).Action_List.Set_Capacity (40);
+ Add_Action (Table.States (256), 10, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 20, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 21, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 22, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 23, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 33, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 35, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 37, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 38, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 40, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 42, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 43, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 53, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 55, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 68, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 74, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 75, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 76, 236);
+ Add_Action (Table.States (256), 77, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 78, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 80, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 83, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 84, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 85, 238);
+ Add_Action (Table.States (256), 86, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 87, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 88, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 89, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 90, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 92, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 93, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 95, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 96, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 97, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 98, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 99, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 100, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 101, Reduce, (259, 4), 2,
primary_4'Access, null);
+ Add_Action (Table.States (256), 102, 240);
+ Add_Action (Table.States (256), 103, 241);
+ Table.States (256).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (256), 116, 242);
+ Add_Goto (Table.States (256), 323, 243);
+ Table.States (256).Kernel := To_Vector (((129, 240, 2, True),
(240, 240, 5, True), (240, 240, 2, True),
+ (259, 240, 0, False), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (256).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 259, 2)));
+ Table.States (257).Action_List.Set_Capacity (35);
+ Add_Action (Table.States (257), (10, 20, 21, 22, 23, 33, 35, 37,
38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
+ 78, 80, 83, 84, 86, 87, 88, 89, 90, 92, 93, 95, 96, 97, 98, 99,
100), (198, 3), 2, null, null);
+ Table.States (257).Kernel := To_Vector ((0 => (198, 259, 0,
False)));
+ Table.States (257).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 198, 2)));
+ Table.States (258).Action_List.Set_Capacity (21);
+ Add_Action (Table.States (258), 10, Reduce, (276, 1), 2, null,
null);
+ Add_Action (Table.States (258), 20, Reduce, (276, 1), 2, null,
null);
+ Add_Action (Table.States (258), 21, Reduce, (276, 1), 2, null,
null);
+ Add_Action (Table.States (258), 22, Reduce, (276, 1), 2, null,
null);
+ Add_Action (Table.States (258), 23, Reduce, (276, 1), 2, null,
null);
+ Add_Action (Table.States (258), 35, Reduce, (276, 1), 2, null,
null);
+ Add_Action (Table.States (258), 37, Reduce, (276, 1), 2, null,
null);
+ Add_Action (Table.States (258), 43, Reduce, (276, 1), 2, null,
null);
+ Add_Action (Table.States (258), 53, Reduce, (276, 1), 2, null,
null);
+ Add_Action (Table.States (258), 68, Reduce, (276, 1), 2, null,
null);
+ Add_Action (Table.States (258), 74, 434);
+ Add_Conflict (Table.States (258), 74, (276, 1), 2, null, null);
+ Add_Action (Table.States (258), 75, Reduce, (276, 1), 2, null,
null);
+ Add_Action (Table.States (258), 76, 236);
+ Add_Action (Table.States (258), 77, Reduce, (276, 1), 2, null,
null);
+ Add_Action (Table.States (258), 80, Reduce, (276, 1), 2, null,
null);
+ Add_Action (Table.States (258), 84, Reduce, (276, 1), 2, null,
null);
+ Add_Action (Table.States (258), 85, 238);
+ Add_Action (Table.States (258), 88, Reduce, (276, 1), 2, null,
null);
+ Add_Action (Table.States (258), 97, Reduce, (276, 1), 2, null,
null);
+ Add_Action (Table.States (258), 102, 240);
+ Add_Action (Table.States (258), 103, 241);
+ Table.States (258).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (258), 116, 242);
+ Add_Goto (Table.States (258), 323, 243);
+ Table.States (258).Kernel := To_Vector (((129, 240, 2, True),
(240, 240, 5, True), (240, 240, 2, True),
+ (273, 240, 3, True), (276, 240, 1, True), (276, 240, 0, False),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True), (294, 240, 2, True)));
+ Table.States (258).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 276, 2)));
+ Table.States (258).Minimal_Complete_Actions_Recursive := True;
+ Table.States (259).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (259), 3, 122);
+ Add_Action (Table.States (259), 35, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (259), 39, 123);
+ Add_Action (Table.States (259), 40, 124);
+ Add_Action (Table.States (259), 41, 125);
+ Add_Action (Table.States (259), 52, 126);
+ Add_Action (Table.States (259), 76, 127);
+ Add_Action (Table.States (259), 79, 31);
+ Add_Action (Table.States (259), 95, 128);
+ Add_Action (Table.States (259), 96, 129);
+ Add_Action (Table.States (259), 104, 130);
+ Add_Action (Table.States (259), 105, 120);
+ Add_Action (Table.States (259), 106, 34);
+ Add_Action (Table.States (259), 107, 35);
+ Table.States (259).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (259), 118, 131);
+ Add_Goto (Table.States (259), 129, 42);
+ Add_Goto (Table.States (259), 192, 132);
+ Add_Goto (Table.States (259), 193, 435);
+ Add_Goto (Table.States (259), 198, 134);
+ Add_Goto (Table.States (259), 240, 135);
+ Add_Goto (Table.States (259), 259, 136);
+ Add_Goto (Table.States (259), 273, 93);
+ Add_Goto (Table.States (259), 276, 137);
+ Add_Goto (Table.States (259), 283, 138);
+ Add_Goto (Table.States (259), 284, 139);
+ Add_Goto (Table.States (259), 285, 140);
+ Add_Goto (Table.States (259), 286, 141);
+ Add_Goto (Table.States (259), 287, 142);
+ Add_Goto (Table.States (259), 288, 143);
+ Add_Goto (Table.States (259), 294, 98);
+ Add_Goto (Table.States (259), 302, 144);
+ Add_Goto (Table.States (259), 321, 145);
+ Add_Goto (Table.States (259), 322, 146);
+ Add_Goto (Table.States (259), 331, 147);
+ Table.States (259).Kernel := To_Vector ((0 => (137, 15, 3,
False)));
+ Table.States (259).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (260).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (260), 9, 436);
+ Add_Action (Table.States (260), 62, 437);
+ Add_Action (Table.States (260), 105, 438);
+ Table.States (260).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (260), 275, 439);
+ Table.States (260).Kernel := To_Vector (((125, 28, 4, False),
(274, 28, 5, False)));
+ Table.States (260).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 438)));
+ Table.States (261).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (261), 3, 122);
+ Add_Action (Table.States (261), 39, 123);
+ Add_Action (Table.States (261), 40, 124);
+ Add_Action (Table.States (261), 41, 125);
+ Add_Action (Table.States (261), 52, 126);
+ Add_Action (Table.States (261), 68, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (261), 76, 127);
+ Add_Action (Table.States (261), 79, 31);
+ Add_Action (Table.States (261), 95, 128);
+ Add_Action (Table.States (261), 96, 129);
+ Add_Action (Table.States (261), 104, 130);
+ Add_Action (Table.States (261), 105, 120);
Add_Action (Table.States (261), 106, 34);
- Table.States (261).Goto_List.Set_Capacity (6);
- Add_Goto (Table.States (261), 117, 130);
- Add_Goto (Table.States (261), 128, 41);
- Add_Goto (Table.States (261), 239, 134);
- Add_Goto (Table.States (261), 258, 256);
- Add_Goto (Table.States (261), 272, 92);
- Add_Goto (Table.States (261), 293, 97);
- Table.States (261).Kernel := To_Vector (((165, 40, 2, False),
(197, 40, 1, False)));
- Table.States (261).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
- Table.States (262).Action_List.Set_Capacity (26);
- Add_Action (Table.States (262), 10, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (262), 33, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (262), 38, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (262), 40, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (262), 43, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (262), 54, 440);
- Add_Action (Table.States (262), 55, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (262), 74, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (262), 75, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (262), 77, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (262), 78, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (262), 79, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (262), 83, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (262), 85, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (262), 86, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (262), 87, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (262), 88, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (262), 89, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (262), 91, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (262), 92, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (262), 94, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (262), 95, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (262), 97, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (262), 98, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (262), 99, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (262), 100, Reduce, (258, 1), 1, null,
null);
- Table.States (262).Kernel := To_Vector (((117, 41, 2, False),
(258, 41, 0, False)));
- Table.States (262).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 258, 1)));
- Table.States (263).Action_List.Set_Capacity (2);
- Add_Action (Table.States (263), (79, 87), (165, 3), 1, null, null);
- Table.States (263).Kernel := To_Vector ((0 => (165, 44, 0,
False)));
- Table.States (263).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 165, 1)));
- Table.States (264).Action_List.Set_Capacity (32);
- Add_Action (Table.States (264), 10, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 33, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 35, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 38, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 40, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 43, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 53, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 55, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 74, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 75, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 76, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 77, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 78, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 79, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 83, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 84, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 85, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 86, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 87, 441);
- Add_Conflict (Table.States (264), 87, (239, 6), 1, null, null);
- Add_Action (Table.States (264), 88, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 89, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 91, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 92, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 94, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 95, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 96, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 97, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 98, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 99, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 100, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 101, Reduce, (239, 6), 1, null,
null);
- Add_Action (Table.States (264), 102, Reduce, (239, 6), 1, null,
null);
- Table.States (264).Kernel := To_Vector (((124, 106, 1, False),
(124, 106, 2, False), (239, 106, 0,
+ Add_Action (Table.States (261), 107, 35);
+ Table.States (261).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (261), 118, 131);
+ Add_Goto (Table.States (261), 129, 42);
+ Add_Goto (Table.States (261), 192, 132);
+ Add_Goto (Table.States (261), 193, 440);
+ Add_Goto (Table.States (261), 198, 134);
+ Add_Goto (Table.States (261), 240, 135);
+ Add_Goto (Table.States (261), 259, 136);
+ Add_Goto (Table.States (261), 273, 93);
+ Add_Goto (Table.States (261), 276, 137);
+ Add_Goto (Table.States (261), 283, 138);
+ Add_Goto (Table.States (261), 284, 139);
+ Add_Goto (Table.States (261), 285, 140);
+ Add_Goto (Table.States (261), 286, 141);
+ Add_Goto (Table.States (261), 287, 142);
+ Add_Goto (Table.States (261), 288, 143);
+ Add_Goto (Table.States (261), 294, 98);
+ Add_Goto (Table.States (261), 302, 144);
+ Add_Goto (Table.States (261), 321, 145);
+ Add_Goto (Table.States (261), 322, 146);
+ Add_Goto (Table.States (261), 331, 147);
+ Table.States (261).Kernel := To_Vector (((222, 32, 4, False),
(222, 32, 2, False), (222, 32, 3, False),
+ (222, 32, 1, False)));
+ Table.States (261).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (262).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (262), 39, 123);
+ Add_Action (Table.States (262), 41, 441);
+ Add_Action (Table.States (262), 76, 127);
+ Add_Action (Table.States (262), 79, 31);
+ Add_Action (Table.States (262), 104, 130);
+ Add_Action (Table.States (262), 105, 120);
+ Add_Action (Table.States (262), 106, 34);
+ Add_Action (Table.States (262), 107, 35);
+ Table.States (262).Goto_List.Set_Capacity (6);
+ Add_Goto (Table.States (262), 118, 131);
+ Add_Goto (Table.States (262), 129, 42);
+ Add_Goto (Table.States (262), 240, 135);
+ Add_Goto (Table.States (262), 259, 257);
+ Add_Goto (Table.States (262), 273, 93);
+ Add_Goto (Table.States (262), 294, 98);
+ Table.States (262).Kernel := To_Vector (((166, 40, 2, False),
(198, 40, 1, False)));
+ Table.States (262).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
+ Table.States (263).Action_List.Set_Capacity (26);
+ Add_Action (Table.States (263), 10, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (263), 33, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (263), 38, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (263), 40, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (263), 43, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (263), 54, 442);
+ Add_Action (Table.States (263), 55, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (263), 74, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (263), 75, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (263), 77, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (263), 78, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (263), 80, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (263), 84, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (263), 86, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (263), 87, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (263), 88, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (263), 89, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (263), 90, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (263), 92, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (263), 93, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (263), 95, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (263), 96, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (263), 98, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (263), 99, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (263), 100, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (263), 101, Reduce, (259, 1), 1, null,
null);
+ Table.States (263).Kernel := To_Vector (((118, 41, 2, False),
(259, 41, 0, False)));
+ Table.States (263).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 259, 1)));
+ Table.States (264).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (264), (80, 88), (166, 3), 1, null, null);
+ Table.States (264).Kernel := To_Vector ((0 => (166, 44, 0,
False)));
+ Table.States (264).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 166, 1)));
+ Table.States (265).Action_List.Set_Capacity (32);
+ Add_Action (Table.States (265), 10, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 33, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 35, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 38, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 40, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 43, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 53, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 55, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 74, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 75, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 76, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 77, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 78, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 80, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 84, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 85, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 86, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 87, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 88, 443);
+ Add_Conflict (Table.States (265), 88, (240, 6), 1, null, null);
+ Add_Action (Table.States (265), 89, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 90, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 92, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 93, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 95, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 96, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 97, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 98, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 99, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 100, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 101, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 102, Reduce, (240, 6), 1, null,
null);
+ Add_Action (Table.States (265), 103, Reduce, (240, 6), 1, null,
null);
+ Table.States (265).Kernel := To_Vector (((125, 107, 1, False),
(125, 107, 2, False), (240, 107, 0,
False)));
- Table.States (264).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 239, 1)));
- Table.States (265).Action_List.Set_Capacity (4);
- Add_Action (Table.States (265), (35, 77, 83, 96), (125, 1), 1,
null, null);
- Table.States (265).Kernel := To_Vector ((0 => (125, 124, 0,
False)));
- Table.States (265).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 125, 1)));
- Table.States (266).Action_List.Set_Capacity (2);
- Add_Action (Table.States (266), 77, 442);
- Add_Action (Table.States (266), 83, 443);
- Table.States (266).Kernel := To_Vector (((117, 125, 1, False),
(125, 125, 1, True)));
- Table.States (266).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 442)));
- Table.States (267).Action_List.Set_Capacity (1);
- Add_Action (Table.States (267), (1 => 77), (153, 1), 1, null,
null);
- Table.States (267).Kernel := To_Vector ((0 => (153, 136, 0,
False)));
- Table.States (267).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 153, 1)));
+ Table.States (265).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 240, 1)));
+ Table.States (266).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (266), (35, 77, 84, 97), (126, 1), 1,
null, null);
+ Table.States (266).Kernel := To_Vector ((0 => (126, 125, 0,
False)));
+ Table.States (266).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 126, 1)));
+ Table.States (267).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (267), 77, 444);
+ Add_Action (Table.States (267), 84, 445);
+ Table.States (267).Kernel := To_Vector (((118, 126, 1, False),
(126, 126, 1, True)));
+ Table.States (267).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 444)));
Table.States (268).Action_List.Set_Capacity (1);
- Add_Action (Table.States (268), 77, 444);
- Table.States (268).Kernel := To_Vector ((0 => (117, 153, 1,
False)));
- Table.States (268).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 444)));
- Table.States (269).Action_List.Set_Capacity (2);
- Add_Action (Table.States (269), (79, 87), (166, 1), 1, null, null);
- Table.States (269).Kernel := To_Vector ((0 => (166, 165, 0,
False)));
- Table.States (269).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 166, 1)));
+ Add_Action (Table.States (268), (1 => 77), (154, 1), 1, null,
null);
+ Table.States (268).Kernel := To_Vector ((0 => (154, 137, 0,
False)));
+ Table.States (268).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 154, 1)));
+ Table.States (269).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (269), 77, 446);
+ Table.States (269).Kernel := To_Vector ((0 => (118, 154, 1,
False)));
+ Table.States (269).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 446)));
Table.States (270).Action_List.Set_Capacity (2);
- Add_Action (Table.States (270), 79, 445);
- Add_Action (Table.States (270), 87, 446);
- Table.States (270).Kernel := To_Vector (((124, 166, 1, False),
(124, 166, 2, False), (166, 166, 2, True)));
- Table.States (270).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 87, 446)));
- Table.States (271).Action_List.Set_Capacity (5);
- Add_Action (Table.States (271), 74, Reduce, (192, 0), 1, null,
null);
- Add_Action (Table.States (271), 77, Reduce, (124, 4), 1,
association_opt_4'Access, null);
- Add_Conflict (Table.States (271), 77, (192, 0), 1, null, null);
- Add_Action (Table.States (271), 79, Reduce, (165, 0), 1, null,
null);
- Add_Action (Table.States (271), 83, Reduce, (124, 4), 1,
association_opt_4'Access, null);
- Add_Action (Table.States (271), 87, Reduce, (165, 0), 1, null,
null);
- Table.States (271).Kernel := To_Vector (((124, 191, 0, False),
(165, 191, 0, False), (192, 191, 0, True)));
- Table.States (271).Minimal_Complete_Actions := To_Vector
(((Reduce, 124, 1), (Reduce, 165, 1), (Reduce,
- 192, 1)));
- Table.States (271).Minimal_Complete_Actions_Recursive := True;
- Table.States (272).Action_List.Set_Capacity (1);
- Add_Action (Table.States (272), 74, 447);
- Table.States (272).Kernel := To_Vector (((117, 192, 4, False),
(117, 192, 2, False)));
- Table.States (272).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 74, 447)));
+ Add_Action (Table.States (270), (80, 88), (167, 1), 1, null, null);
+ Table.States (270).Kernel := To_Vector ((0 => (167, 166, 0,
False)));
+ Table.States (270).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 167, 1)));
+ Table.States (271).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (271), 80, 447);
+ Add_Action (Table.States (271), 88, 448);
+ Table.States (271).Kernel := To_Vector (((125, 167, 1, False),
(125, 167, 2, False), (167, 167, 2, True)));
+ Table.States (271).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 88, 448)));
+ Table.States (272).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (272), 74, 449);
+ Add_Conflict (Table.States (272), 74, (193, 0), 1, null, null);
+ Add_Action (Table.States (272), 77, Reduce, (125, 5), 1,
association_opt_5'Access, null);
+ Add_Conflict (Table.States (272), 77, (193, 0), 1, null, null);
+ Add_Action (Table.States (272), 80, Reduce, (166, 0), 1, null,
null);
+ Add_Action (Table.States (272), 84, Reduce, (125, 5), 1,
association_opt_5'Access, null);
+ Add_Action (Table.States (272), 88, Reduce, (166, 0), 1, null,
null);
+ Table.States (272).Kernel := To_Vector (((118, 192, 3, False),
(125, 192, 0, False), (166, 192, 0, False),
+ (193, 192, 0, True)));
+ Table.States (272).Minimal_Complete_Actions := To_Vector
(((Reduce, 125, 1), (Reduce, 166, 1), (Reduce,
+ 193, 1)));
+ Table.States (272).Minimal_Complete_Actions_Recursive := True;
Table.States (273).Action_List.Set_Capacity (1);
- Add_Action (Table.States (273), (1 => 77), (153, 0), 1, null,
null);
- Table.States (273).Kernel := To_Vector ((0 => (153, 221, 0,
False)));
- Table.States (273).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 153, 1)));
- Table.States (274).Action_List.Set_Capacity (38);
- Add_Action (Table.States (274), 10, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 20, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 21, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 22, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 23, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 33, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 35, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 37, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 38, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 40, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 43, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 53, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 55, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 68, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 74, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 75, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 76, 235);
- Add_Action (Table.States (274), 77, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 78, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 79, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 83, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 84, 237);
- Add_Action (Table.States (274), 85, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 86, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 87, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 88, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 89, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 91, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 92, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 94, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 95, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 96, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 97, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 98, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 99, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 100, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (274), 101, 239);
- Add_Action (Table.States (274), 102, 240);
- Table.States (274).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (274), 115, 241);
- Add_Goto (Table.States (274), 322, 448);
- Table.States (274).Kernel := To_Vector (((128, 239, 2, True),
(239, 239, 5, True), (239, 239, 2, True),
- (258, 239, 0, False), (272, 239, 3, True), (277, 239, 4, False),
(277, 239, 2, False), (293, 239, 2, True),
- (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True)));
- Table.States (274).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 258, 1)));
- Table.States (275).Action_List.Set_Capacity (1);
- Add_Action (Table.States (275), (1 => 77), (153, 2), 1, null,
null);
- Table.States (275).Kernel := To_Vector ((0 => (153, 273, 0,
False)));
- Table.States (275).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 153, 1)));
- Table.States (276).Action_List.Set_Capacity (2);
- Add_Action (Table.States (276), (79, 87), (165, 2), 1, null, null);
- Table.States (276).Kernel := To_Vector ((0 => (165, 277, 0,
False)));
- Table.States (276).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 165, 1)));
- Table.States (277).Action_List.Set_Capacity (19);
- Add_Action (Table.States (277), 10, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (277), 33, 288);
- Add_Action (Table.States (277), 35, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (277), 40, 289);
- Add_Action (Table.States (277), 43, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (277), 74, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (277), 75, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (277), 77, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (277), 79, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (277), 83, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (277), 85, 449);
- Add_Action (Table.States (277), 86, 290);
- Add_Action (Table.States (277), 87, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (277), 88, 291);
- Add_Action (Table.States (277), 89, 292);
- Add_Action (Table.States (277), 91, 293);
- Add_Action (Table.States (277), 92, 294);
- Add_Action (Table.States (277), 96, Reduce, (287, 3), 1, null,
null);
- Add_Action (Table.States (277), 98, 295);
- Table.States (277).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (277), 288, 296);
- Table.States (277).Kernel := To_Vector (((277, 301, 2, False),
(287, 301, 3, False), (287, 301, 2, False),
- (287, 301, 2, False), (287, 301, 0, False)));
- Table.States (277).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 287, 1)));
- Table.States (278).Action_List.Set_Capacity (1);
- Add_Action (Table.States (278), 72, 450);
- Table.States (278).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (278), 140, 451);
- Add_Goto (Table.States (278), 141, 452);
- Table.States (278).Kernel := To_Vector ((0 => (139, 35, 5,
False)));
- Table.States (278).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 72, 450)));
- Table.States (279).Action_List.Set_Capacity (7);
- Add_Action (Table.States (279), 39, 122);
- Add_Action (Table.States (279), 41, 124);
- Add_Action (Table.States (279), 76, 126);
- Add_Action (Table.States (279), 103, 129);
- Add_Action (Table.States (279), 104, 119);
- Add_Action (Table.States (279), 105, 33);
- Add_Action (Table.States (279), 106, 34);
- Table.States (279).Goto_List.Set_Capacity (6);
- Add_Goto (Table.States (279), 117, 130);
- Add_Goto (Table.States (279), 128, 41);
- Add_Goto (Table.States (279), 239, 134);
- Add_Goto (Table.States (279), 258, 453);
- Add_Goto (Table.States (279), 272, 92);
- Add_Goto (Table.States (279), 293, 97);
- Table.States (279).Kernel := To_Vector ((0 => (197, 100, 1,
False)));
- Table.States (279).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
- Table.States (280).Action_List.Set_Capacity (12);
- Add_Action (Table.States (280), 3, 121);
- Add_Action (Table.States (280), 39, 122);
- Add_Action (Table.States (280), 40, 123);
- Add_Action (Table.States (280), 41, 124);
- Add_Action (Table.States (280), 52, 125);
- Add_Action (Table.States (280), 76, 126);
- Add_Action (Table.States (280), 94, 127);
- Add_Action (Table.States (280), 95, 128);
- Add_Action (Table.States (280), 103, 129);
- Add_Action (Table.States (280), 104, 119);
- Add_Action (Table.States (280), 105, 33);
+ Add_Action (Table.States (273), 74, 450);
+ Table.States (273).Kernel := To_Vector (((118, 193, 4, False),
(118, 193, 2, False)));
+ Table.States (273).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 74, 450)));
+ Table.States (274).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (274), (1 => 77), (154, 0), 1, null,
null);
+ Table.States (274).Kernel := To_Vector ((0 => (154, 222, 0,
False)));
+ Table.States (274).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 154, 1)));
+ Table.States (275).Action_List.Set_Capacity (38);
+ Add_Action (Table.States (275), 10, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 20, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 21, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 22, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 23, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 33, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 35, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 37, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 38, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 40, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 43, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 53, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 55, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 68, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 74, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 75, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 76, 236);
+ Add_Action (Table.States (275), 77, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 78, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 80, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 84, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 85, 238);
+ Add_Action (Table.States (275), 86, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 87, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 88, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 89, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 90, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 92, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 93, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 95, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 96, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 97, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 98, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 99, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 100, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 101, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (275), 102, 240);
+ Add_Action (Table.States (275), 103, 241);
+ Table.States (275).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (275), 116, 242);
+ Add_Goto (Table.States (275), 323, 451);
+ Table.States (275).Kernel := To_Vector (((129, 240, 2, True),
(240, 240, 5, True), (240, 240, 2, True),
+ (259, 240, 0, False), (273, 240, 3, True), (278, 240, 4, False),
(278, 240, 2, False), (294, 240, 2, True),
+ (294, 240, 2, True), (294, 240, 2, True), (294, 240, 2, True)));
+ Table.States (275).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 259, 1)));
+ Table.States (276).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (276), (1 => 77), (154, 2), 1, null,
null);
+ Table.States (276).Kernel := To_Vector ((0 => (154, 274, 0,
False)));
+ Table.States (276).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 154, 1)));
+ Table.States (277).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (277), (80, 88), (166, 2), 1, null, null);
+ Table.States (277).Kernel := To_Vector ((0 => (166, 278, 0,
False)));
+ Table.States (277).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 166, 1)));
+ Table.States (278).Action_List.Set_Capacity (19);
+ Add_Action (Table.States (278), 10, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (278), 33, 289);
+ Add_Action (Table.States (278), 35, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (278), 40, 290);
+ Add_Action (Table.States (278), 43, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (278), 74, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (278), 75, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (278), 77, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (278), 80, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (278), 84, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (278), 86, 452);
+ Add_Action (Table.States (278), 87, 291);
+ Add_Action (Table.States (278), 88, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (278), 89, 292);
+ Add_Action (Table.States (278), 90, 293);
+ Add_Action (Table.States (278), 92, 294);
+ Add_Action (Table.States (278), 93, 295);
+ Add_Action (Table.States (278), 97, Reduce, (288, 3), 1, null,
null);
+ Add_Action (Table.States (278), 99, 296);
+ Table.States (278).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (278), 289, 297);
+ Table.States (278).Kernel := To_Vector (((278, 302, 2, False),
(288, 302, 3, False), (288, 302, 2, False),
+ (288, 302, 2, False), (288, 302, 0, False)));
+ Table.States (278).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 288, 1)));
+ Table.States (279).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (279), 72, 453);
+ Table.States (279).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (279), 141, 454);
+ Add_Goto (Table.States (279), 142, 455);
+ Table.States (279).Kernel := To_Vector ((0 => (140, 35, 5,
False)));
+ Table.States (279).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 72, 453)));
+ Table.States (280).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (280), 39, 123);
+ Add_Action (Table.States (280), 41, 125);
+ Add_Action (Table.States (280), 76, 127);
+ Add_Action (Table.States (280), 79, 31);
+ Add_Action (Table.States (280), 104, 130);
+ Add_Action (Table.States (280), 105, 120);
Add_Action (Table.States (280), 106, 34);
- Table.States (280).Goto_List.Set_Capacity (13);
- Add_Goto (Table.States (280), 117, 130);
- Add_Goto (Table.States (280), 128, 41);
- Add_Goto (Table.States (280), 197, 133);
- Add_Goto (Table.States (280), 239, 134);
- Add_Goto (Table.States (280), 258, 135);
- Add_Goto (Table.States (280), 272, 92);
- Add_Goto (Table.States (280), 275, 136);
- Add_Goto (Table.States (280), 287, 454);
- Add_Goto (Table.States (280), 293, 97);
- Add_Goto (Table.States (280), 301, 143);
- Add_Goto (Table.States (280), 320, 144);
- Add_Goto (Table.States (280), 321, 145);
- Add_Goto (Table.States (280), 330, 146);
- Table.States (280).Kernel := To_Vector ((0 => (282, 10, 1, True)));
- Table.States (280).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
- Table.States (280).Minimal_Complete_Actions_Recursive := True;
- Table.States (281).Action_List.Set_Capacity (1);
- Add_Action (Table.States (281), 68, 455);
- Table.States (281).Kernel := To_Vector ((0 => (283, 10, 2, True)));
- Table.States (281).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 68, 455)));
+ Add_Action (Table.States (280), 107, 35);
+ Table.States (280).Goto_List.Set_Capacity (6);
+ Add_Goto (Table.States (280), 118, 131);
+ Add_Goto (Table.States (280), 129, 42);
+ Add_Goto (Table.States (280), 240, 135);
+ Add_Goto (Table.States (280), 259, 456);
+ Add_Goto (Table.States (280), 273, 93);
+ Add_Goto (Table.States (280), 294, 98);
+ Table.States (280).Kernel := To_Vector ((0 => (198, 101, 1,
False)));
+ Table.States (280).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
+ Table.States (281).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (281), 3, 122);
+ Add_Action (Table.States (281), 39, 123);
+ Add_Action (Table.States (281), 40, 124);
+ Add_Action (Table.States (281), 41, 125);
+ Add_Action (Table.States (281), 52, 126);
+ Add_Action (Table.States (281), 76, 127);
+ Add_Action (Table.States (281), 79, 31);
+ Add_Action (Table.States (281), 95, 128);
+ Add_Action (Table.States (281), 96, 129);
+ Add_Action (Table.States (281), 104, 130);
+ Add_Action (Table.States (281), 105, 120);
+ Add_Action (Table.States (281), 106, 34);
+ Add_Action (Table.States (281), 107, 35);
+ Table.States (281).Goto_List.Set_Capacity (13);
+ Add_Goto (Table.States (281), 118, 131);
+ Add_Goto (Table.States (281), 129, 42);
+ Add_Goto (Table.States (281), 198, 134);
+ Add_Goto (Table.States (281), 240, 135);
+ Add_Goto (Table.States (281), 259, 136);
+ Add_Goto (Table.States (281), 273, 93);
+ Add_Goto (Table.States (281), 276, 137);
+ Add_Goto (Table.States (281), 288, 457);
+ Add_Goto (Table.States (281), 294, 98);
+ Add_Goto (Table.States (281), 302, 144);
+ Add_Goto (Table.States (281), 321, 145);
+ Add_Goto (Table.States (281), 322, 146);
+ Add_Goto (Table.States (281), 331, 147);
+ Table.States (281).Kernel := To_Vector ((0 => (283, 10, 1, True)));
+ Table.States (281).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
Table.States (281).Minimal_Complete_Actions_Recursive := True;
- Table.States (282).Action_List.Set_Capacity (12);
- Add_Action (Table.States (282), 3, 121);
- Add_Action (Table.States (282), 39, 122);
- Add_Action (Table.States (282), 40, 123);
- Add_Action (Table.States (282), 41, 124);
- Add_Action (Table.States (282), 52, 125);
- Add_Action (Table.States (282), 76, 126);
- Add_Action (Table.States (282), 94, 127);
- Add_Action (Table.States (282), 95, 128);
- Add_Action (Table.States (282), 103, 129);
- Add_Action (Table.States (282), 104, 119);
- Add_Action (Table.States (282), 105, 33);
- Add_Action (Table.States (282), 106, 34);
- Table.States (282).Goto_List.Set_Capacity (13);
- Add_Goto (Table.States (282), 117, 130);
- Add_Goto (Table.States (282), 128, 41);
- Add_Goto (Table.States (282), 197, 133);
- Add_Goto (Table.States (282), 239, 134);
- Add_Goto (Table.States (282), 258, 135);
- Add_Goto (Table.States (282), 272, 92);
- Add_Goto (Table.States (282), 275, 136);
- Add_Goto (Table.States (282), 287, 456);
- Add_Goto (Table.States (282), 293, 97);
- Add_Goto (Table.States (282), 301, 143);
- Add_Goto (Table.States (282), 320, 144);
- Add_Goto (Table.States (282), 321, 145);
- Add_Goto (Table.States (282), 330, 146);
- Table.States (282).Kernel := To_Vector ((0 => (284, 43, 1, True)));
- Table.States (282).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
- Table.States (282).Minimal_Complete_Actions_Recursive := True;
- Table.States (283).Action_List.Set_Capacity (1);
- Add_Action (Table.States (283), 22, 457);
- Table.States (283).Kernel := To_Vector ((0 => (285, 43, 2, True)));
- Table.States (283).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 22, 457)));
- Table.States (283).Minimal_Complete_Actions_Recursive := True;
- Table.States (284).Action_List.Set_Capacity (12);
- Add_Action (Table.States (284), 3, 121);
- Add_Action (Table.States (284), 39, 122);
- Add_Action (Table.States (284), 40, 123);
- Add_Action (Table.States (284), 41, 124);
- Add_Action (Table.States (284), 52, 125);
- Add_Action (Table.States (284), 76, 126);
- Add_Action (Table.States (284), 94, 127);
- Add_Action (Table.States (284), 95, 128);
- Add_Action (Table.States (284), 103, 129);
- Add_Action (Table.States (284), 104, 119);
- Add_Action (Table.States (284), 105, 33);
- Add_Action (Table.States (284), 106, 34);
- Table.States (284).Goto_List.Set_Capacity (13);
- Add_Goto (Table.States (284), 117, 130);
- Add_Goto (Table.States (284), 128, 41);
- Add_Goto (Table.States (284), 197, 133);
- Add_Goto (Table.States (284), 239, 134);
- Add_Goto (Table.States (284), 258, 135);
- Add_Goto (Table.States (284), 272, 92);
- Add_Goto (Table.States (284), 275, 136);
- Add_Goto (Table.States (284), 287, 458);
- Add_Goto (Table.States (284), 293, 97);
- Add_Goto (Table.States (284), 301, 143);
- Add_Goto (Table.States (284), 320, 144);
- Add_Goto (Table.States (284), 321, 145);
- Add_Goto (Table.States (284), 330, 146);
- Table.States (284).Kernel := To_Vector ((0 => (286, 75, 1, True)));
- Table.States (284).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
- Table.States (284).Minimal_Complete_Actions_Recursive := True;
end Subr_5;
procedure Subr_6
is begin
+ Table.States (282).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (282), 68, 458);
+ Table.States (282).Kernel := To_Vector ((0 => (284, 10, 2, True)));
+ Table.States (282).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 68, 458)));
+ Table.States (282).Minimal_Complete_Actions_Recursive := True;
+ Table.States (283).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (283), 3, 122);
+ Add_Action (Table.States (283), 39, 123);
+ Add_Action (Table.States (283), 40, 124);
+ Add_Action (Table.States (283), 41, 125);
+ Add_Action (Table.States (283), 52, 126);
+ Add_Action (Table.States (283), 76, 127);
+ Add_Action (Table.States (283), 79, 31);
+ Add_Action (Table.States (283), 95, 128);
+ Add_Action (Table.States (283), 96, 129);
+ Add_Action (Table.States (283), 104, 130);
+ Add_Action (Table.States (283), 105, 120);
+ Add_Action (Table.States (283), 106, 34);
+ Add_Action (Table.States (283), 107, 35);
+ Table.States (283).Goto_List.Set_Capacity (13);
+ Add_Goto (Table.States (283), 118, 131);
+ Add_Goto (Table.States (283), 129, 42);
+ Add_Goto (Table.States (283), 198, 134);
+ Add_Goto (Table.States (283), 240, 135);
+ Add_Goto (Table.States (283), 259, 136);
+ Add_Goto (Table.States (283), 273, 93);
+ Add_Goto (Table.States (283), 276, 137);
+ Add_Goto (Table.States (283), 288, 459);
+ Add_Goto (Table.States (283), 294, 98);
+ Add_Goto (Table.States (283), 302, 144);
+ Add_Goto (Table.States (283), 321, 145);
+ Add_Goto (Table.States (283), 322, 146);
+ Add_Goto (Table.States (283), 331, 147);
+ Table.States (283).Kernel := To_Vector ((0 => (285, 43, 1, True)));
+ Table.States (283).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
+ Table.States (283).Minimal_Complete_Actions_Recursive := True;
+ Table.States (284).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (284), 22, 460);
+ Table.States (284).Kernel := To_Vector ((0 => (286, 43, 2, True)));
+ Table.States (284).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 22, 460)));
+ Table.States (284).Minimal_Complete_Actions_Recursive := True;
Table.States (285).Action_List.Set_Capacity (13);
- Add_Action (Table.States (285), 3, 121);
- Add_Action (Table.States (285), 39, 122);
- Add_Action (Table.States (285), 40, 123);
- Add_Action (Table.States (285), 41, 124);
- Add_Action (Table.States (285), 52, 125);
- Add_Action (Table.States (285), 68, 459);
- Add_Action (Table.States (285), 76, 126);
- Add_Action (Table.States (285), 94, 127);
+ Add_Action (Table.States (285), 3, 122);
+ Add_Action (Table.States (285), 39, 123);
+ Add_Action (Table.States (285), 40, 124);
+ Add_Action (Table.States (285), 41, 125);
+ Add_Action (Table.States (285), 52, 126);
+ Add_Action (Table.States (285), 76, 127);
+ Add_Action (Table.States (285), 79, 31);
Add_Action (Table.States (285), 95, 128);
- Add_Action (Table.States (285), 103, 129);
- Add_Action (Table.States (285), 104, 119);
- Add_Action (Table.States (285), 105, 33);
+ Add_Action (Table.States (285), 96, 129);
+ Add_Action (Table.States (285), 104, 130);
+ Add_Action (Table.States (285), 105, 120);
Add_Action (Table.States (285), 106, 34);
+ Add_Action (Table.States (285), 107, 35);
Table.States (285).Goto_List.Set_Capacity (13);
- Add_Goto (Table.States (285), 117, 130);
- Add_Goto (Table.States (285), 128, 41);
- Add_Goto (Table.States (285), 197, 133);
- Add_Goto (Table.States (285), 239, 134);
- Add_Goto (Table.States (285), 258, 135);
- Add_Goto (Table.States (285), 272, 92);
- Add_Goto (Table.States (285), 275, 136);
- Add_Goto (Table.States (285), 287, 460);
- Add_Goto (Table.States (285), 293, 97);
- Add_Goto (Table.States (285), 301, 143);
- Add_Goto (Table.States (285), 320, 144);
+ Add_Goto (Table.States (285), 118, 131);
+ Add_Goto (Table.States (285), 129, 42);
+ Add_Goto (Table.States (285), 198, 134);
+ Add_Goto (Table.States (285), 240, 135);
+ Add_Goto (Table.States (285), 259, 136);
+ Add_Goto (Table.States (285), 273, 93);
+ Add_Goto (Table.States (285), 276, 137);
+ Add_Goto (Table.States (285), 288, 461);
+ Add_Goto (Table.States (285), 294, 98);
+ Add_Goto (Table.States (285), 302, 144);
Add_Goto (Table.States (285), 321, 145);
- Add_Goto (Table.States (285), 330, 146);
- Table.States (285).Kernel := To_Vector (((282, 10, 1, True), (283,
10, 2, True)));
- Table.States (285).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
+ Add_Goto (Table.States (285), 322, 146);
+ Add_Goto (Table.States (285), 331, 147);
+ Table.States (285).Kernel := To_Vector ((0 => (287, 75, 1, True)));
+ Table.States (285).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
Table.States (285).Minimal_Complete_Actions_Recursive := True;
- Table.States (286).Action_List.Set_Capacity (13);
- Add_Action (Table.States (286), 3, 121);
- Add_Action (Table.States (286), 22, 461);
- Add_Action (Table.States (286), 39, 122);
- Add_Action (Table.States (286), 40, 123);
- Add_Action (Table.States (286), 41, 124);
- Add_Action (Table.States (286), 52, 125);
- Add_Action (Table.States (286), 76, 126);
- Add_Action (Table.States (286), 94, 127);
+ Table.States (286).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (286), 3, 122);
+ Add_Action (Table.States (286), 39, 123);
+ Add_Action (Table.States (286), 40, 124);
+ Add_Action (Table.States (286), 41, 125);
+ Add_Action (Table.States (286), 52, 126);
+ Add_Action (Table.States (286), 68, 462);
+ Add_Action (Table.States (286), 76, 127);
+ Add_Action (Table.States (286), 79, 31);
Add_Action (Table.States (286), 95, 128);
- Add_Action (Table.States (286), 103, 129);
- Add_Action (Table.States (286), 104, 119);
- Add_Action (Table.States (286), 105, 33);
+ Add_Action (Table.States (286), 96, 129);
+ Add_Action (Table.States (286), 104, 130);
+ Add_Action (Table.States (286), 105, 120);
Add_Action (Table.States (286), 106, 34);
+ Add_Action (Table.States (286), 107, 35);
Table.States (286).Goto_List.Set_Capacity (13);
- Add_Goto (Table.States (286), 117, 130);
- Add_Goto (Table.States (286), 128, 41);
- Add_Goto (Table.States (286), 197, 133);
- Add_Goto (Table.States (286), 239, 134);
- Add_Goto (Table.States (286), 258, 135);
- Add_Goto (Table.States (286), 272, 92);
- Add_Goto (Table.States (286), 275, 136);
- Add_Goto (Table.States (286), 287, 462);
- Add_Goto (Table.States (286), 293, 97);
- Add_Goto (Table.States (286), 301, 143);
- Add_Goto (Table.States (286), 320, 144);
+ Add_Goto (Table.States (286), 118, 131);
+ Add_Goto (Table.States (286), 129, 42);
+ Add_Goto (Table.States (286), 198, 134);
+ Add_Goto (Table.States (286), 240, 135);
+ Add_Goto (Table.States (286), 259, 136);
+ Add_Goto (Table.States (286), 273, 93);
+ Add_Goto (Table.States (286), 276, 137);
+ Add_Goto (Table.States (286), 288, 463);
+ Add_Goto (Table.States (286), 294, 98);
+ Add_Goto (Table.States (286), 302, 144);
Add_Goto (Table.States (286), 321, 145);
- Add_Goto (Table.States (286), 330, 146);
- Table.States (286).Kernel := To_Vector (((284, 43, 1, True), (285,
43, 2, True)));
- Table.States (286).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
+ Add_Goto (Table.States (286), 322, 146);
+ Add_Goto (Table.States (286), 331, 147);
+ Table.States (286).Kernel := To_Vector (((283, 10, 1, True), (284,
10, 2, True)));
+ Table.States (286).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
Table.States (286).Minimal_Complete_Actions_Recursive := True;
- Table.States (287).Action_List.Set_Capacity (12);
- Add_Action (Table.States (287), 3, 121);
- Add_Action (Table.States (287), 39, 122);
- Add_Action (Table.States (287), 40, 123);
- Add_Action (Table.States (287), 41, 124);
- Add_Action (Table.States (287), 52, 125);
- Add_Action (Table.States (287), 76, 126);
- Add_Action (Table.States (287), 94, 127);
+ Table.States (287).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (287), 3, 122);
+ Add_Action (Table.States (287), 22, 464);
+ Add_Action (Table.States (287), 39, 123);
+ Add_Action (Table.States (287), 40, 124);
+ Add_Action (Table.States (287), 41, 125);
+ Add_Action (Table.States (287), 52, 126);
+ Add_Action (Table.States (287), 76, 127);
+ Add_Action (Table.States (287), 79, 31);
Add_Action (Table.States (287), 95, 128);
- Add_Action (Table.States (287), 103, 129);
- Add_Action (Table.States (287), 104, 119);
- Add_Action (Table.States (287), 105, 33);
+ Add_Action (Table.States (287), 96, 129);
+ Add_Action (Table.States (287), 104, 130);
+ Add_Action (Table.States (287), 105, 120);
Add_Action (Table.States (287), 106, 34);
+ Add_Action (Table.States (287), 107, 35);
Table.States (287).Goto_List.Set_Capacity (13);
- Add_Goto (Table.States (287), 117, 130);
- Add_Goto (Table.States (287), 128, 41);
- Add_Goto (Table.States (287), 197, 133);
- Add_Goto (Table.States (287), 239, 134);
- Add_Goto (Table.States (287), 258, 135);
- Add_Goto (Table.States (287), 272, 92);
- Add_Goto (Table.States (287), 275, 136);
- Add_Goto (Table.States (287), 287, 463);
- Add_Goto (Table.States (287), 293, 97);
- Add_Goto (Table.States (287), 301, 143);
- Add_Goto (Table.States (287), 320, 144);
+ Add_Goto (Table.States (287), 118, 131);
+ Add_Goto (Table.States (287), 129, 42);
+ Add_Goto (Table.States (287), 198, 134);
+ Add_Goto (Table.States (287), 240, 135);
+ Add_Goto (Table.States (287), 259, 136);
+ Add_Goto (Table.States (287), 273, 93);
+ Add_Goto (Table.States (287), 276, 137);
+ Add_Goto (Table.States (287), 288, 465);
+ Add_Goto (Table.States (287), 294, 98);
+ Add_Goto (Table.States (287), 302, 144);
Add_Goto (Table.States (287), 321, 145);
- Add_Goto (Table.States (287), 330, 146);
- Table.States (287).Kernel := To_Vector ((0 => (286, 75, 1, True)));
- Table.States (287).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
+ Add_Goto (Table.States (287), 322, 146);
+ Add_Goto (Table.States (287), 331, 147);
+ Table.States (287).Kernel := To_Vector (((285, 43, 1, True), (286,
43, 2, True)));
+ Table.States (287).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
Table.States (287).Minimal_Complete_Actions_Recursive := True;
- Table.States (288).Action_List.Set_Capacity (11);
- Add_Action (Table.States (288), 3, 121);
- Add_Action (Table.States (288), 39, 122);
- Add_Action (Table.States (288), 40, 123);
- Add_Action (Table.States (288), 41, 124);
- Add_Action (Table.States (288), 76, 126);
- Add_Action (Table.States (288), 94, 127);
+ Table.States (288).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (288), 3, 122);
+ Add_Action (Table.States (288), 39, 123);
+ Add_Action (Table.States (288), 40, 124);
+ Add_Action (Table.States (288), 41, 125);
+ Add_Action (Table.States (288), 52, 126);
+ Add_Action (Table.States (288), 76, 127);
+ Add_Action (Table.States (288), 79, 31);
Add_Action (Table.States (288), 95, 128);
- Add_Action (Table.States (288), 103, 129);
- Add_Action (Table.States (288), 104, 119);
- Add_Action (Table.States (288), 105, 33);
+ Add_Action (Table.States (288), 96, 129);
+ Add_Action (Table.States (288), 104, 130);
+ Add_Action (Table.States (288), 105, 120);
Add_Action (Table.States (288), 106, 34);
- Table.States (288).Goto_List.Set_Capacity (14);
- Add_Goto (Table.States (288), 117, 130);
- Add_Goto (Table.States (288), 128, 41);
- Add_Goto (Table.States (288), 197, 133);
- Add_Goto (Table.States (288), 233, 464);
- Add_Goto (Table.States (288), 234, 465);
- Add_Goto (Table.States (288), 239, 274);
- Add_Goto (Table.States (288), 258, 135);
- Add_Goto (Table.States (288), 272, 92);
- Add_Goto (Table.States (288), 277, 466);
- Add_Goto (Table.States (288), 293, 97);
- Add_Goto (Table.States (288), 301, 467);
- Add_Goto (Table.States (288), 320, 144);
+ Add_Action (Table.States (288), 107, 35);
+ Table.States (288).Goto_List.Set_Capacity (13);
+ Add_Goto (Table.States (288), 118, 131);
+ Add_Goto (Table.States (288), 129, 42);
+ Add_Goto (Table.States (288), 198, 134);
+ Add_Goto (Table.States (288), 240, 135);
+ Add_Goto (Table.States (288), 259, 136);
+ Add_Goto (Table.States (288), 273, 93);
+ Add_Goto (Table.States (288), 276, 137);
+ Add_Goto (Table.States (288), 288, 466);
+ Add_Goto (Table.States (288), 294, 98);
+ Add_Goto (Table.States (288), 302, 144);
Add_Goto (Table.States (288), 321, 145);
- Add_Goto (Table.States (288), 330, 146);
- Table.States (288).Kernel := To_Vector ((0 => (287, 33, 1,
False)));
- Table.States (288).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
- Table.States (289).Action_List.Set_Capacity (1);
- Add_Action (Table.States (289), 33, 468);
- Table.States (289).Kernel := To_Vector ((0 => (287, 40, 2,
False)));
- Table.States (289).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 468)));
- Table.States (290).Action_List.Set_Capacity (11);
- Add_Action (Table.States (290), (3, 39, 40, 41, 76, 94, 95, 103,
104, 105, 106), (288, 0), 1, null, null);
- Table.States (290).Kernel := To_Vector ((0 => (288, 86, 0,
False)));
- Table.States (290).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 288, 1)));
- Table.States (291).Action_List.Set_Capacity (11);
- Add_Action (Table.States (291), (3, 39, 40, 41, 76, 94, 95, 103,
104, 105, 106), (288, 4), 1, null, null);
- Table.States (291).Kernel := To_Vector ((0 => (288, 88, 0,
False)));
- Table.States (291).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 288, 1)));
- Table.States (292).Action_List.Set_Capacity (11);
- Add_Action (Table.States (292), (3, 39, 40, 41, 76, 94, 95, 103,
104, 105, 106), (288, 5), 1, null, null);
- Table.States (292).Kernel := To_Vector ((0 => (288, 89, 0,
False)));
- Table.States (292).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 288, 1)));
- Table.States (293).Action_List.Set_Capacity (11);
- Add_Action (Table.States (293), (3, 39, 40, 41, 76, 94, 95, 103,
104, 105, 106), (288, 2), 1, null, null);
- Table.States (293).Kernel := To_Vector ((0 => (288, 91, 0,
False)));
- Table.States (293).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 288, 1)));
- Table.States (294).Action_List.Set_Capacity (11);
- Add_Action (Table.States (294), (3, 39, 40, 41, 76, 94, 95, 103,
104, 105, 106), (288, 3), 1, null, null);
- Table.States (294).Kernel := To_Vector ((0 => (288, 92, 0,
False)));
- Table.States (294).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 288, 1)));
- Table.States (295).Action_List.Set_Capacity (11);
- Add_Action (Table.States (295), (3, 39, 40, 41, 76, 94, 95, 103,
104, 105, 106), (288, 1), 1, null, null);
- Table.States (295).Kernel := To_Vector ((0 => (288, 98, 0,
False)));
- Table.States (295).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 288, 1)));
- Table.States (296).Action_List.Set_Capacity (11);
- Add_Action (Table.States (296), 3, 121);
- Add_Action (Table.States (296), 39, 122);
- Add_Action (Table.States (296), 40, 123);
- Add_Action (Table.States (296), 41, 124);
- Add_Action (Table.States (296), 76, 126);
- Add_Action (Table.States (296), 94, 127);
- Add_Action (Table.States (296), 95, 128);
- Add_Action (Table.States (296), 103, 129);
- Add_Action (Table.States (296), 104, 119);
- Add_Action (Table.States (296), 105, 33);
- Add_Action (Table.States (296), 106, 34);
- Table.States (296).Goto_List.Set_Capacity (11);
- Add_Goto (Table.States (296), 117, 130);
- Add_Goto (Table.States (296), 128, 41);
- Add_Goto (Table.States (296), 197, 133);
- Add_Goto (Table.States (296), 239, 134);
- Add_Goto (Table.States (296), 258, 135);
- Add_Goto (Table.States (296), 272, 92);
- Add_Goto (Table.States (296), 293, 97);
- Add_Goto (Table.States (296), 301, 469);
- Add_Goto (Table.States (296), 320, 144);
- Add_Goto (Table.States (296), 321, 145);
- Add_Goto (Table.States (296), 330, 146);
- Table.States (296).Kernel := To_Vector ((0 => (287, 288, 1,
False)));
- Table.States (296).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
- Table.States (297).Action_List.Set_Capacity (9);
- Add_Action (Table.States (297), (3, 39, 40, 41, 76, 103, 104, 105,
106), (237, 2), 1, null, null);
- Table.States (297).Kernel := To_Vector ((0 => (237, 38, 0,
False)));
- Table.States (297).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 237, 1)));
- Table.States (298).Action_List.Set_Capacity (9);
- Add_Action (Table.States (298), (3, 39, 40, 41, 76, 103, 104, 105,
106), (237, 3), 1, null, null);
- Table.States (298).Kernel := To_Vector ((0 => (237, 55, 0,
False)));
- Table.States (298).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 237, 1)));
- Table.States (299).Action_List.Set_Capacity (9);
- Add_Action (Table.States (299), (3, 39, 40, 41, 76, 103, 104, 105,
106), (237, 1), 1, null, null);
- Table.States (299).Kernel := To_Vector ((0 => (237, 97, 0,
False)));
- Table.States (299).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 237, 1)));
- Table.States (300).Action_List.Set_Capacity (9);
- Add_Action (Table.States (300), (3, 39, 40, 41, 76, 103, 104, 105,
106), (237, 0), 1, null, null);
- Table.States (300).Kernel := To_Vector ((0 => (237, 99, 0,
False)));
- Table.States (300).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 237, 1)));
- Table.States (301).Action_List.Set_Capacity (9);
- Add_Action (Table.States (301), 3, 121);
- Add_Action (Table.States (301), 39, 122);
- Add_Action (Table.States (301), 40, 123);
- Add_Action (Table.States (301), 41, 124);
- Add_Action (Table.States (301), 76, 126);
- Add_Action (Table.States (301), 103, 129);
- Add_Action (Table.States (301), 104, 119);
- Add_Action (Table.States (301), 105, 33);
- Add_Action (Table.States (301), 106, 34);
- Table.States (301).Goto_List.Set_Capacity (7);
- Add_Goto (Table.States (301), 117, 130);
- Add_Goto (Table.States (301), 128, 41);
- Add_Goto (Table.States (301), 197, 470);
- Add_Goto (Table.States (301), 239, 134);
- Add_Goto (Table.States (301), 258, 135);
- Add_Goto (Table.States (301), 272, 92);
- Add_Goto (Table.States (301), 293, 97);
- Table.States (301).Kernel := To_Vector ((0 => (320, 237, 1,
True)));
- Table.States (301).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
- Table.States (301).Minimal_Complete_Actions_Recursive := True;
- Table.States (302).Action_List.Set_Capacity (9);
- Add_Action (Table.States (302), (3, 39, 40, 41, 76, 103, 104, 105,
106), (130, 2), 1, null, null);
- Table.States (302).Kernel := To_Vector ((0 => (130, 78, 0,
False)));
- Table.States (302).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 130, 1)));
- Table.States (303).Action_List.Set_Capacity (9);
- Add_Action (Table.States (303), (3, 39, 40, 41, 76, 103, 104, 105,
106), (130, 1), 1, null, null);
- Table.States (303).Kernel := To_Vector ((0 => (130, 94, 0,
False)));
- Table.States (303).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 130, 1)));
- Table.States (304).Action_List.Set_Capacity (9);
- Add_Action (Table.States (304), (3, 39, 40, 41, 76, 103, 104, 105,
106), (130, 0), 1, null, null);
- Table.States (304).Kernel := To_Vector ((0 => (130, 95, 0,
False)));
- Table.States (304).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 130, 1)));
- Table.States (305).Action_List.Set_Capacity (9);
- Add_Action (Table.States (305), 3, 121);
- Add_Action (Table.States (305), 39, 122);
- Add_Action (Table.States (305), 40, 123);
- Add_Action (Table.States (305), 41, 124);
- Add_Action (Table.States (305), 76, 126);
- Add_Action (Table.States (305), 103, 129);
- Add_Action (Table.States (305), 104, 119);
- Add_Action (Table.States (305), 105, 33);
- Add_Action (Table.States (305), 106, 34);
- Table.States (305).Goto_List.Set_Capacity (8);
- Add_Goto (Table.States (305), 117, 130);
- Add_Goto (Table.States (305), 128, 41);
- Add_Goto (Table.States (305), 197, 133);
- Add_Goto (Table.States (305), 239, 134);
- Add_Goto (Table.States (305), 258, 135);
- Add_Goto (Table.States (305), 272, 92);
- Add_Goto (Table.States (305), 293, 97);
- Add_Goto (Table.States (305), 320, 471);
- Table.States (305).Kernel := To_Vector ((0 => (321, 130, 1,
True)));
- Table.States (305).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
- Table.States (305).Minimal_Complete_Actions_Recursive := True;
- Table.States (306).Action_List.Set_Capacity (31);
- Add_Action (Table.States (306), 10, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 20, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 21, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 22, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 23, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 33, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 35, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 37, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 40, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 42, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 43, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 53, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 68, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 74, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 75, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 77, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 78, 302);
- Add_Action (Table.States (306), 79, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 82, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 83, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 85, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 86, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 87, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 88, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 89, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 91, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 92, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 94, 303);
- Add_Action (Table.States (306), 95, 304);
- Add_Action (Table.States (306), 96, Reduce, (301, 0), 2, null,
null);
- Add_Action (Table.States (306), 98, Reduce, (301, 0), 2, null,
null);
- Table.States (306).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (306), 130, 305);
- Table.States (306).Kernel := To_Vector (((301, 321, 0, False),
(321, 321, 2, True)));
- Table.States (306).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 301, 2)));
- Table.States (307).Action_List.Set_Capacity (1);
- Add_Action (Table.States (307), 96, 472);
- Table.States (307).Kernel := To_Vector ((0 => (161, 192, 1,
False)));
- Table.States (307).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 472)));
- Table.States (308).Action_List.Set_Capacity (46);
- Add_Action (Table.States (308), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (161, 1), 3, delay_statement_1'Access, null);
- Table.States (308).Kernel := To_Vector ((0 => (161, 96, 0,
False)));
- Table.States (308).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 161, 3)));
- Table.States (309).Action_List.Set_Capacity (13);
- Add_Action (Table.States (309), 3, 121);
- Add_Action (Table.States (309), 39, 122);
- Add_Action (Table.States (309), 40, 123);
- Add_Action (Table.States (309), 41, 124);
- Add_Action (Table.States (309), 52, 125);
- Add_Action (Table.States (309), 76, 126);
- Add_Action (Table.States (309), 94, 127);
- Add_Action (Table.States (309), 95, 128);
- Add_Action (Table.States (309), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (309), 103, 129);
- Add_Action (Table.States (309), 104, 119);
- Add_Action (Table.States (309), 105, 33);
- Add_Action (Table.States (309), 106, 34);
- Table.States (309).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (309), 117, 130);
- Add_Goto (Table.States (309), 128, 41);
- Add_Goto (Table.States (309), 191, 131);
- Add_Goto (Table.States (309), 192, 473);
- Add_Goto (Table.States (309), 197, 133);
- Add_Goto (Table.States (309), 239, 134);
- Add_Goto (Table.States (309), 258, 135);
- Add_Goto (Table.States (309), 272, 92);
- Add_Goto (Table.States (309), 275, 136);
- Add_Goto (Table.States (309), 282, 137);
- Add_Goto (Table.States (309), 283, 138);
- Add_Goto (Table.States (309), 284, 139);
- Add_Goto (Table.States (309), 285, 140);
- Add_Goto (Table.States (309), 286, 141);
- Add_Goto (Table.States (309), 287, 142);
- Add_Goto (Table.States (309), 293, 97);
- Add_Goto (Table.States (309), 301, 143);
- Add_Goto (Table.States (309), 320, 144);
- Add_Goto (Table.States (309), 321, 145);
- Add_Goto (Table.States (309), 330, 146);
- Table.States (309).Kernel := To_Vector ((0 => (190, 72, 1,
False)));
- Table.States (309).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (310).Action_List.Set_Capacity (46);
- Add_Action (Table.States (310), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (190, 1), 3, exit_statement_1'Access, null);
- Table.States (310).Kernel := To_Vector ((0 => (190, 96, 0,
False)));
- Table.States (310).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 190, 3)));
- Table.States (311).Action_List.Set_Capacity (12);
- Add_Action (Table.States (311), 3, 121);
- Add_Action (Table.States (311), 39, 122);
- Add_Action (Table.States (311), 40, 474);
- Add_Action (Table.States (311), 41, 124);
- Add_Action (Table.States (311), 59, 475);
- Add_Action (Table.States (311), 76, 126);
- Add_Action (Table.States (311), 94, 127);
- Add_Action (Table.States (311), 95, 128);
- Add_Action (Table.States (311), 103, 129);
- Add_Action (Table.States (311), 104, 119);
- Add_Action (Table.States (311), 105, 33);
- Add_Action (Table.States (311), 106, 34);
- Table.States (311).Goto_List.Set_Capacity (14);
- Add_Goto (Table.States (311), 117, 130);
- Add_Goto (Table.States (311), 128, 41);
- Add_Goto (Table.States (311), 167, 476);
- Add_Goto (Table.States (311), 197, 133);
- Add_Goto (Table.States (311), 239, 477);
- Add_Goto (Table.States (311), 258, 135);
- Add_Goto (Table.States (311), 272, 92);
- Add_Goto (Table.States (311), 277, 478);
- Add_Goto (Table.States (311), 293, 97);
- Add_Goto (Table.States (311), 301, 479);
- Add_Goto (Table.States (311), 314, 480);
- Add_Goto (Table.States (311), 320, 144);
- Add_Goto (Table.States (311), 321, 145);
- Add_Goto (Table.States (311), 330, 146);
- Table.States (311).Kernel := To_Vector (((230, 33, 2, False),
(230, 33, 1, False)));
- Table.States (311).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (312).Action_List.Set_Capacity (4);
- Add_Action (Table.States (312), 59, 481);
- Add_Action (Table.States (312), 104, 119);
- Add_Action (Table.States (312), 105, 33);
+ Add_Goto (Table.States (288), 322, 146);
+ Add_Goto (Table.States (288), 331, 147);
+ Table.States (288).Kernel := To_Vector ((0 => (287, 75, 1, True)));
+ Table.States (288).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
+ Table.States (288).Minimal_Complete_Actions_Recursive := True;
+ Table.States (289).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (289), 3, 122);
+ Add_Action (Table.States (289), 39, 123);
+ Add_Action (Table.States (289), 40, 124);
+ Add_Action (Table.States (289), 41, 125);
+ Add_Action (Table.States (289), 76, 127);
+ Add_Action (Table.States (289), 79, 31);
+ Add_Action (Table.States (289), 95, 128);
+ Add_Action (Table.States (289), 96, 129);
+ Add_Action (Table.States (289), 104, 130);
+ Add_Action (Table.States (289), 105, 120);
+ Add_Action (Table.States (289), 106, 34);
+ Add_Action (Table.States (289), 107, 35);
+ Table.States (289).Goto_List.Set_Capacity (14);
+ Add_Goto (Table.States (289), 118, 131);
+ Add_Goto (Table.States (289), 129, 42);
+ Add_Goto (Table.States (289), 198, 134);
+ Add_Goto (Table.States (289), 234, 467);
+ Add_Goto (Table.States (289), 235, 468);
+ Add_Goto (Table.States (289), 240, 275);
+ Add_Goto (Table.States (289), 259, 136);
+ Add_Goto (Table.States (289), 273, 93);
+ Add_Goto (Table.States (289), 278, 469);
+ Add_Goto (Table.States (289), 294, 98);
+ Add_Goto (Table.States (289), 302, 470);
+ Add_Goto (Table.States (289), 321, 145);
+ Add_Goto (Table.States (289), 322, 146);
+ Add_Goto (Table.States (289), 331, 147);
+ Table.States (289).Kernel := To_Vector ((0 => (288, 33, 1,
False)));
+ Table.States (289).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
+ Table.States (290).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (290), 33, 471);
+ Table.States (290).Kernel := To_Vector ((0 => (288, 40, 2,
False)));
+ Table.States (290).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 471)));
+ Table.States (291).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (291), (3, 39, 40, 41, 76, 79, 95, 96,
104, 105, 106, 107), (289, 0), 1, null,
+ null);
+ Table.States (291).Kernel := To_Vector ((0 => (289, 87, 0,
False)));
+ Table.States (291).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 289, 1)));
+ Table.States (292).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (292), (3, 39, 40, 41, 76, 79, 95, 96,
104, 105, 106, 107), (289, 4), 1, null,
+ null);
+ Table.States (292).Kernel := To_Vector ((0 => (289, 89, 0,
False)));
+ Table.States (292).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 289, 1)));
+ Table.States (293).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (293), (3, 39, 40, 41, 76, 79, 95, 96,
104, 105, 106, 107), (289, 5), 1, null,
+ null);
+ Table.States (293).Kernel := To_Vector ((0 => (289, 90, 0,
False)));
+ Table.States (293).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 289, 1)));
+ Table.States (294).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (294), (3, 39, 40, 41, 76, 79, 95, 96,
104, 105, 106, 107), (289, 2), 1, null,
+ null);
+ Table.States (294).Kernel := To_Vector ((0 => (289, 92, 0,
False)));
+ Table.States (294).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 289, 1)));
+ Table.States (295).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (295), (3, 39, 40, 41, 76, 79, 95, 96,
104, 105, 106, 107), (289, 3), 1, null,
+ null);
+ Table.States (295).Kernel := To_Vector ((0 => (289, 93, 0,
False)));
+ Table.States (295).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 289, 1)));
+ Table.States (296).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (296), (3, 39, 40, 41, 76, 79, 95, 96,
104, 105, 106, 107), (289, 1), 1, null,
+ null);
+ Table.States (296).Kernel := To_Vector ((0 => (289, 99, 0,
False)));
+ Table.States (296).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 289, 1)));
+ Table.States (297).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (297), 3, 122);
+ Add_Action (Table.States (297), 39, 123);
+ Add_Action (Table.States (297), 40, 124);
+ Add_Action (Table.States (297), 41, 125);
+ Add_Action (Table.States (297), 76, 127);
+ Add_Action (Table.States (297), 79, 31);
+ Add_Action (Table.States (297), 95, 128);
+ Add_Action (Table.States (297), 96, 129);
+ Add_Action (Table.States (297), 104, 130);
+ Add_Action (Table.States (297), 105, 120);
+ Add_Action (Table.States (297), 106, 34);
+ Add_Action (Table.States (297), 107, 35);
+ Table.States (297).Goto_List.Set_Capacity (11);
+ Add_Goto (Table.States (297), 118, 131);
+ Add_Goto (Table.States (297), 129, 42);
+ Add_Goto (Table.States (297), 198, 134);
+ Add_Goto (Table.States (297), 240, 135);
+ Add_Goto (Table.States (297), 259, 136);
+ Add_Goto (Table.States (297), 273, 93);
+ Add_Goto (Table.States (297), 294, 98);
+ Add_Goto (Table.States (297), 302, 472);
+ Add_Goto (Table.States (297), 321, 145);
+ Add_Goto (Table.States (297), 322, 146);
+ Add_Goto (Table.States (297), 331, 147);
+ Table.States (297).Kernel := To_Vector ((0 => (288, 289, 1,
False)));
+ Table.States (297).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
+ Table.States (298).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (298), (3, 39, 40, 41, 76, 79, 104, 105,
106, 107), (238, 2), 1, null, null);
+ Table.States (298).Kernel := To_Vector ((0 => (238, 38, 0,
False)));
+ Table.States (298).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 238, 1)));
+ Table.States (299).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (299), (3, 39, 40, 41, 76, 79, 104, 105,
106, 107), (238, 3), 1, null, null);
+ Table.States (299).Kernel := To_Vector ((0 => (238, 55, 0,
False)));
+ Table.States (299).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 238, 1)));
+ Table.States (300).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (300), (3, 39, 40, 41, 76, 79, 104, 105,
106, 107), (238, 1), 1, null, null);
+ Table.States (300).Kernel := To_Vector ((0 => (238, 98, 0,
False)));
+ Table.States (300).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 238, 1)));
+ Table.States (301).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (301), (3, 39, 40, 41, 76, 79, 104, 105,
106, 107), (238, 0), 1, null, null);
+ Table.States (301).Kernel := To_Vector ((0 => (238, 100, 0,
False)));
+ Table.States (301).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 238, 1)));
+ Table.States (302).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (302), 3, 122);
+ Add_Action (Table.States (302), 39, 123);
+ Add_Action (Table.States (302), 40, 124);
+ Add_Action (Table.States (302), 41, 125);
+ Add_Action (Table.States (302), 76, 127);
+ Add_Action (Table.States (302), 79, 31);
+ Add_Action (Table.States (302), 104, 130);
+ Add_Action (Table.States (302), 105, 120);
+ Add_Action (Table.States (302), 106, 34);
+ Add_Action (Table.States (302), 107, 35);
+ Table.States (302).Goto_List.Set_Capacity (7);
+ Add_Goto (Table.States (302), 118, 131);
+ Add_Goto (Table.States (302), 129, 42);
+ Add_Goto (Table.States (302), 198, 473);
+ Add_Goto (Table.States (302), 240, 135);
+ Add_Goto (Table.States (302), 259, 136);
+ Add_Goto (Table.States (302), 273, 93);
+ Add_Goto (Table.States (302), 294, 98);
+ Table.States (302).Kernel := To_Vector ((0 => (321, 238, 1,
True)));
+ Table.States (302).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
+ Table.States (302).Minimal_Complete_Actions_Recursive := True;
+ Table.States (303).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (303), (3, 39, 40, 41, 76, 79, 104, 105,
106, 107), (131, 2), 1, null, null);
+ Table.States (303).Kernel := To_Vector ((0 => (131, 78, 0,
False)));
+ Table.States (303).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 131, 1)));
+ Table.States (304).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (304), (3, 39, 40, 41, 76, 79, 104, 105,
106, 107), (131, 1), 1, null, null);
+ Table.States (304).Kernel := To_Vector ((0 => (131, 95, 0,
False)));
+ Table.States (304).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 131, 1)));
+ Table.States (305).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (305), (3, 39, 40, 41, 76, 79, 104, 105,
106, 107), (131, 0), 1, null, null);
+ Table.States (305).Kernel := To_Vector ((0 => (131, 96, 0,
False)));
+ Table.States (305).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 131, 1)));
+ Table.States (306).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (306), 3, 122);
+ Add_Action (Table.States (306), 39, 123);
+ Add_Action (Table.States (306), 40, 124);
+ Add_Action (Table.States (306), 41, 125);
+ Add_Action (Table.States (306), 76, 127);
+ Add_Action (Table.States (306), 79, 31);
+ Add_Action (Table.States (306), 104, 130);
+ Add_Action (Table.States (306), 105, 120);
+ Add_Action (Table.States (306), 106, 34);
+ Add_Action (Table.States (306), 107, 35);
+ Table.States (306).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (306), 118, 131);
+ Add_Goto (Table.States (306), 129, 42);
+ Add_Goto (Table.States (306), 198, 134);
+ Add_Goto (Table.States (306), 240, 135);
+ Add_Goto (Table.States (306), 259, 136);
+ Add_Goto (Table.States (306), 273, 93);
+ Add_Goto (Table.States (306), 294, 98);
+ Add_Goto (Table.States (306), 321, 474);
+ Table.States (306).Kernel := To_Vector ((0 => (322, 131, 1,
True)));
+ Table.States (306).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
+ Table.States (306).Minimal_Complete_Actions_Recursive := True;
+ Table.States (307).Action_List.Set_Capacity (31);
+ Add_Action (Table.States (307), 10, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 20, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 21, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 22, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 23, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 33, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 35, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 37, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 40, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 42, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 43, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 53, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 68, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 74, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 75, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 77, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 78, 303);
+ Add_Action (Table.States (307), 80, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 83, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 84, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 86, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 87, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 88, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 89, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 90, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 92, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 93, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 95, 304);
+ Add_Action (Table.States (307), 96, 305);
+ Add_Action (Table.States (307), 97, Reduce, (302, 0), 2, null,
null);
+ Add_Action (Table.States (307), 99, Reduce, (302, 0), 2, null,
null);
+ Table.States (307).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (307), 131, 306);
+ Table.States (307).Kernel := To_Vector (((302, 322, 0, False),
(322, 322, 2, True)));
+ Table.States (307).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 302, 2)));
+ Table.States (308).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (308), 97, 475);
+ Table.States (308).Kernel := To_Vector ((0 => (162, 193, 1,
False)));
+ Table.States (308).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 475)));
+ Table.States (309).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (309), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (162, 1), 3, delay_statement_1'Access, null);
+ Table.States (309).Kernel := To_Vector ((0 => (162, 97, 0,
False)));
+ Table.States (309).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 162, 3)));
+ Table.States (310).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (310), 3, 122);
+ Add_Action (Table.States (310), 39, 123);
+ Add_Action (Table.States (310), 40, 124);
+ Add_Action (Table.States (310), 41, 125);
+ Add_Action (Table.States (310), 52, 126);
+ Add_Action (Table.States (310), 76, 127);
+ Add_Action (Table.States (310), 79, 31);
+ Add_Action (Table.States (310), 95, 128);
+ Add_Action (Table.States (310), 96, 129);
+ Add_Action (Table.States (310), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (310), 104, 130);
+ Add_Action (Table.States (310), 105, 120);
+ Add_Action (Table.States (310), 106, 34);
+ Add_Action (Table.States (310), 107, 35);
+ Table.States (310).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (310), 118, 131);
+ Add_Goto (Table.States (310), 129, 42);
+ Add_Goto (Table.States (310), 192, 132);
+ Add_Goto (Table.States (310), 193, 476);
+ Add_Goto (Table.States (310), 198, 134);
+ Add_Goto (Table.States (310), 240, 135);
+ Add_Goto (Table.States (310), 259, 136);
+ Add_Goto (Table.States (310), 273, 93);
+ Add_Goto (Table.States (310), 276, 137);
+ Add_Goto (Table.States (310), 283, 138);
+ Add_Goto (Table.States (310), 284, 139);
+ Add_Goto (Table.States (310), 285, 140);
+ Add_Goto (Table.States (310), 286, 141);
+ Add_Goto (Table.States (310), 287, 142);
+ Add_Goto (Table.States (310), 288, 143);
+ Add_Goto (Table.States (310), 294, 98);
+ Add_Goto (Table.States (310), 302, 144);
+ Add_Goto (Table.States (310), 321, 145);
+ Add_Goto (Table.States (310), 322, 146);
+ Add_Goto (Table.States (310), 331, 147);
+ Table.States (310).Kernel := To_Vector ((0 => (191, 72, 1,
False)));
+ Table.States (310).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (311).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (311), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (191, 1), 3, exit_statement_1'Access, null);
+ Table.States (311).Kernel := To_Vector ((0 => (191, 97, 0,
False)));
+ Table.States (311).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 191, 3)));
+ Table.States (312).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (312), 3, 122);
+ Add_Action (Table.States (312), 39, 123);
+ Add_Action (Table.States (312), 40, 477);
+ Add_Action (Table.States (312), 41, 125);
+ Add_Action (Table.States (312), 59, 478);
+ Add_Action (Table.States (312), 76, 127);
+ Add_Action (Table.States (312), 79, 31);
+ Add_Action (Table.States (312), 95, 128);
+ Add_Action (Table.States (312), 96, 129);
+ Add_Action (Table.States (312), 104, 130);
+ Add_Action (Table.States (312), 105, 120);
Add_Action (Table.States (312), 106, 34);
- Table.States (312).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (312), 128, 41);
- Add_Goto (Table.States (312), 239, 482);
- Add_Goto (Table.States (312), 272, 92);
- Add_Goto (Table.States (312), 293, 97);
- Table.States (312).Kernel := To_Vector (((230, 42, 2, False),
(230, 42, 1, False)));
- Table.States (312).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (313).Action_List.Set_Capacity (4);
- Add_Action (Table.States (313), 40, 483);
- Add_Action (Table.States (313), 104, 119);
- Add_Action (Table.States (313), 105, 33);
+ Add_Action (Table.States (312), 107, 35);
+ Table.States (312).Goto_List.Set_Capacity (14);
+ Add_Goto (Table.States (312), 118, 131);
+ Add_Goto (Table.States (312), 129, 42);
+ Add_Goto (Table.States (312), 168, 479);
+ Add_Goto (Table.States (312), 198, 134);
+ Add_Goto (Table.States (312), 240, 480);
+ Add_Goto (Table.States (312), 259, 136);
+ Add_Goto (Table.States (312), 273, 93);
+ Add_Goto (Table.States (312), 278, 481);
+ Add_Goto (Table.States (312), 294, 98);
+ Add_Goto (Table.States (312), 302, 482);
+ Add_Goto (Table.States (312), 315, 483);
+ Add_Goto (Table.States (312), 321, 145);
+ Add_Goto (Table.States (312), 322, 146);
+ Add_Goto (Table.States (312), 331, 147);
+ Table.States (312).Kernel := To_Vector (((231, 33, 2, False),
(231, 33, 1, False)));
+ Table.States (312).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (313).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (313), 59, 484);
+ Add_Action (Table.States (313), 79, 31);
+ Add_Action (Table.States (313), 105, 120);
Add_Action (Table.States (313), 106, 34);
- Table.States (313).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (313), 128, 41);
- Add_Goto (Table.States (313), 239, 484);
- Add_Goto (Table.States (313), 272, 92);
- Add_Goto (Table.States (313), 293, 97);
- Add_Goto (Table.States (313), 314, 485);
- Table.States (313).Kernel := To_Vector (((230, 81, 4, False),
(230, 81, 3, False)));
- Table.States (313).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (314).Action_List.Set_Capacity (13);
- Add_Action (Table.States (314), 3, 121);
- Add_Action (Table.States (314), 39, 122);
- Add_Action (Table.States (314), 40, 123);
- Add_Action (Table.States (314), 41, 124);
- Add_Action (Table.States (314), 52, 125);
- Add_Action (Table.States (314), 76, 126);
- Add_Action (Table.States (314), 94, 127);
- Add_Action (Table.States (314), 95, 128);
- Add_Action (Table.States (314), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (314), 103, 129);
- Add_Action (Table.States (314), 104, 119);
- Add_Action (Table.States (314), 105, 33);
+ Add_Action (Table.States (313), 107, 35);
+ Table.States (313).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (313), 129, 42);
+ Add_Goto (Table.States (313), 240, 485);
+ Add_Goto (Table.States (313), 273, 93);
+ Add_Goto (Table.States (313), 294, 98);
+ Table.States (313).Kernel := To_Vector (((231, 42, 2, False),
(231, 42, 1, False)));
+ Table.States (313).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (314).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (314), 40, 486);
+ Add_Action (Table.States (314), 79, 31);
+ Add_Action (Table.States (314), 105, 120);
Add_Action (Table.States (314), 106, 34);
- Table.States (314).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (314), 117, 130);
- Add_Goto (Table.States (314), 128, 41);
- Add_Goto (Table.States (314), 191, 131);
- Add_Goto (Table.States (314), 192, 486);
- Add_Goto (Table.States (314), 197, 133);
- Add_Goto (Table.States (314), 239, 134);
- Add_Goto (Table.States (314), 258, 135);
- Add_Goto (Table.States (314), 272, 92);
- Add_Goto (Table.States (314), 275, 136);
- Add_Goto (Table.States (314), 282, 137);
- Add_Goto (Table.States (314), 283, 138);
- Add_Goto (Table.States (314), 284, 139);
- Add_Goto (Table.States (314), 285, 140);
- Add_Goto (Table.States (314), 286, 141);
- Add_Goto (Table.States (314), 287, 142);
- Add_Goto (Table.States (314), 293, 97);
- Add_Goto (Table.States (314), 301, 143);
- Add_Goto (Table.States (314), 320, 144);
- Add_Goto (Table.States (314), 321, 145);
- Add_Goto (Table.States (314), 330, 146);
- Table.States (314).Kernel := To_Vector ((0 => (121, 71, 1,
False)));
- Table.States (314).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (315).Action_List.Set_Capacity (1);
- Add_Action (Table.States (315), 12, 487);
- Table.States (315).Kernel := To_Vector ((0 => (127, 71, 2,
False)));
- Table.States (315).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 12, 487)));
- Table.States (316).Action_List.Set_Capacity (2);
- Add_Action (Table.States (316), 54, 488);
- Add_Action (Table.States (316), 76, 126);
- Table.States (316).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (316), 117, 489);
- Table.States (316).Kernel := To_Vector (((182, 71, 3, False),
(281, 71, 12, False)));
- Table.States (316).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 76, 126)));
- Table.States (317).Action_List.Set_Capacity (12);
- Add_Action (Table.States (317), 7, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (317), 21, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (317), 35, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (317), 40, 386);
- Add_Action (Table.States (317), 56, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (317), 74, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (317), 77, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (317), 82, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (317), 96, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (317), 104, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (317), 105, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (317), 106, Reduce, (241, 1), 0, null,
null);
- Table.States (317).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (317), 114, 490);
- Add_Goto (Table.States (317), 241, 491);
- Table.States (317).Kernel := To_Vector (((291, 58, 0, False),
(291, 58, 2, True)));
- Table.States (317).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 241, 0)));
- Table.States (318).Action_List.Set_Capacity (21);
- Add_Action (Table.States (318), 3, 121);
- Add_Action (Table.States (318), 15, 258);
- Add_Action (Table.States (318), 28, 259);
- Add_Action (Table.States (318), 32, 260);
- Add_Action (Table.States (318), 39, 122);
- Add_Action (Table.States (318), 40, 261);
- Add_Action (Table.States (318), 41, 124);
- Add_Action (Table.States (318), 44, 263);
- Add_Action (Table.States (318), 52, 125);
- Add_Action (Table.States (318), 76, 126);
- Add_Action (Table.States (318), 77, Reduce, (124, 5), 0, null,
null);
- Add_Conflict (Table.States (318), 77, (254, 4), 0, null, null);
- Add_Action (Table.States (318), 79, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (318), 83, Reduce, (124, 5), 0, null,
null);
- Add_Action (Table.States (318), 87, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (318), 94, 127);
- Add_Action (Table.States (318), 95, 128);
- Add_Action (Table.States (318), 96, Reduce, (254, 4), 0, null,
null);
- Add_Action (Table.States (318), 103, 129);
- Add_Action (Table.States (318), 104, 492);
- Add_Action (Table.States (318), 105, 33);
- Add_Action (Table.States (318), 106, 264);
- Table.States (318).Goto_List.Set_Capacity (32);
- Add_Goto (Table.States (318), 117, 130);
- Add_Goto (Table.States (318), 124, 265);
- Add_Goto (Table.States (318), 125, 406);
- Add_Goto (Table.States (318), 128, 41);
- Add_Goto (Table.States (318), 136, 267);
- Add_Goto (Table.States (318), 153, 407);
- Add_Goto (Table.States (318), 165, 269);
- Add_Goto (Table.States (318), 166, 270);
- Add_Goto (Table.States (318), 191, 408);
- Add_Goto (Table.States (318), 197, 133);
- Add_Goto (Table.States (318), 219, 493);
- Add_Goto (Table.States (318), 221, 273);
- Add_Goto (Table.States (318), 239, 274);
- Add_Goto (Table.States (318), 254, 494);
- Add_Goto (Table.States (318), 255, 495);
- Add_Goto (Table.States (318), 258, 135);
- Add_Goto (Table.States (318), 272, 92);
- Add_Goto (Table.States (318), 273, 275);
- Add_Goto (Table.States (318), 275, 136);
- Add_Goto (Table.States (318), 277, 409);
- Add_Goto (Table.States (318), 278, 410);
- Add_Goto (Table.States (318), 282, 137);
- Add_Goto (Table.States (318), 283, 138);
- Add_Goto (Table.States (318), 284, 139);
- Add_Goto (Table.States (318), 285, 140);
- Add_Goto (Table.States (318), 286, 141);
- Add_Goto (Table.States (318), 287, 142);
- Add_Goto (Table.States (318), 293, 97);
- Add_Goto (Table.States (318), 301, 277);
- Add_Goto (Table.States (318), 320, 144);
- Add_Goto (Table.States (318), 321, 145);
- Add_Goto (Table.States (318), 330, 146);
- Table.States (318).Kernel := To_Vector (((115, 76, 1, False),
(115, 76, 3, False), (199, 76, 1, False),
- (239, 76, 4, True)));
- Table.States (318).Minimal_Complete_Actions := To_Vector
(((Reduce, 125, 0), (Reduce, 255, 0)));
- Table.States (318).Minimal_Complete_Actions_Recursive := True;
- Table.States (319).Action_List.Set_Capacity (1);
- Add_Action (Table.States (319), 58, 317);
- Table.States (319).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (319), 291, 496);
- Table.States (319).Kernel := To_Vector ((0 => (252, 199, 1,
True)));
- Table.States (319).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 58, 317)));
+ Add_Action (Table.States (314), 107, 35);
+ Table.States (314).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (314), 129, 42);
+ Add_Goto (Table.States (314), 240, 487);
+ Add_Goto (Table.States (314), 273, 93);
+ Add_Goto (Table.States (314), 294, 98);
+ Add_Goto (Table.States (314), 315, 488);
+ Table.States (314).Kernel := To_Vector (((231, 82, 4, False),
(231, 82, 3, False)));
+ Table.States (314).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (315).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (315), 3, 122);
+ Add_Action (Table.States (315), 39, 123);
+ Add_Action (Table.States (315), 40, 124);
+ Add_Action (Table.States (315), 41, 125);
+ Add_Action (Table.States (315), 52, 126);
+ Add_Action (Table.States (315), 76, 127);
+ Add_Action (Table.States (315), 79, 31);
+ Add_Action (Table.States (315), 95, 128);
+ Add_Action (Table.States (315), 96, 129);
+ Add_Action (Table.States (315), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (315), 104, 130);
+ Add_Action (Table.States (315), 105, 120);
+ Add_Action (Table.States (315), 106, 34);
+ Add_Action (Table.States (315), 107, 35);
+ Table.States (315).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (315), 118, 131);
+ Add_Goto (Table.States (315), 129, 42);
+ Add_Goto (Table.States (315), 192, 132);
+ Add_Goto (Table.States (315), 193, 489);
+ Add_Goto (Table.States (315), 198, 134);
+ Add_Goto (Table.States (315), 240, 135);
+ Add_Goto (Table.States (315), 259, 136);
+ Add_Goto (Table.States (315), 273, 93);
+ Add_Goto (Table.States (315), 276, 137);
+ Add_Goto (Table.States (315), 283, 138);
+ Add_Goto (Table.States (315), 284, 139);
+ Add_Goto (Table.States (315), 285, 140);
+ Add_Goto (Table.States (315), 286, 141);
+ Add_Goto (Table.States (315), 287, 142);
+ Add_Goto (Table.States (315), 288, 143);
+ Add_Goto (Table.States (315), 294, 98);
+ Add_Goto (Table.States (315), 302, 144);
+ Add_Goto (Table.States (315), 321, 145);
+ Add_Goto (Table.States (315), 322, 146);
+ Add_Goto (Table.States (315), 331, 147);
+ Table.States (315).Kernel := To_Vector ((0 => (122, 71, 1,
False)));
+ Table.States (315).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (316).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (316), 12, 490);
+ Table.States (316).Kernel := To_Vector ((0 => (128, 71, 2,
False)));
+ Table.States (316).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 12, 490)));
+ Table.States (317).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (317), 54, 491);
+ Add_Action (Table.States (317), 76, 127);
+ Table.States (317).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (317), 118, 492);
+ Table.States (317).Kernel := To_Vector (((183, 71, 3, False),
(282, 71, 12, False)));
+ Table.States (317).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 76, 127)));
+ Table.States (318).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (318), 7, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (318), 21, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (318), 35, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (318), 40, 387);
+ Add_Action (Table.States (318), 56, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (318), 74, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (318), 77, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (318), 79, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (318), 83, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (318), 97, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (318), 105, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (318), 106, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (318), 107, Reduce, (242, 1), 0, null,
null);
+ Table.States (318).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (318), 115, 493);
+ Add_Goto (Table.States (318), 242, 494);
+ Table.States (318).Kernel := To_Vector (((292, 58, 0, False),
(292, 58, 2, True)));
+ Table.States (318).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 242, 0)));
+ Table.States (319).Action_List.Set_Capacity (22);
+ Add_Action (Table.States (319), 3, 122);
+ Add_Action (Table.States (319), 15, 259);
+ Add_Action (Table.States (319), 28, 260);
+ Add_Action (Table.States (319), 32, 261);
+ Add_Action (Table.States (319), 39, 123);
+ Add_Action (Table.States (319), 40, 262);
+ Add_Action (Table.States (319), 41, 125);
+ Add_Action (Table.States (319), 44, 264);
+ Add_Action (Table.States (319), 52, 126);
+ Add_Action (Table.States (319), 76, 127);
+ Add_Action (Table.States (319), 77, Reduce, (125, 6), 0, null,
null);
+ Add_Conflict (Table.States (319), 77, (255, 4), 0, null, null);
+ Add_Action (Table.States (319), 79, 31);
+ Add_Action (Table.States (319), 80, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (319), 84, Reduce, (125, 6), 0, null,
null);
+ Add_Action (Table.States (319), 88, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (319), 95, 128);
+ Add_Action (Table.States (319), 96, 129);
+ Add_Action (Table.States (319), 97, Reduce, (255, 4), 0, null,
null);
+ Add_Action (Table.States (319), 104, 130);
+ Add_Action (Table.States (319), 105, 495);
+ Add_Action (Table.States (319), 106, 34);
+ Add_Action (Table.States (319), 107, 265);
+ Table.States (319).Goto_List.Set_Capacity (32);
+ Add_Goto (Table.States (319), 118, 131);
+ Add_Goto (Table.States (319), 125, 266);
+ Add_Goto (Table.States (319), 126, 407);
+ Add_Goto (Table.States (319), 129, 42);
+ Add_Goto (Table.States (319), 137, 268);
+ Add_Goto (Table.States (319), 154, 408);
+ Add_Goto (Table.States (319), 166, 270);
+ Add_Goto (Table.States (319), 167, 271);
+ Add_Goto (Table.States (319), 192, 409);
+ Add_Goto (Table.States (319), 198, 134);
+ Add_Goto (Table.States (319), 220, 496);
+ Add_Goto (Table.States (319), 222, 274);
+ Add_Goto (Table.States (319), 240, 275);
+ Add_Goto (Table.States (319), 255, 497);
+ Add_Goto (Table.States (319), 256, 498);
+ Add_Goto (Table.States (319), 259, 136);
+ Add_Goto (Table.States (319), 273, 93);
+ Add_Goto (Table.States (319), 274, 276);
+ Add_Goto (Table.States (319), 276, 137);
+ Add_Goto (Table.States (319), 278, 410);
+ Add_Goto (Table.States (319), 279, 411);
+ Add_Goto (Table.States (319), 283, 138);
+ Add_Goto (Table.States (319), 284, 139);
+ Add_Goto (Table.States (319), 285, 140);
+ Add_Goto (Table.States (319), 286, 141);
+ Add_Goto (Table.States (319), 287, 142);
+ Add_Goto (Table.States (319), 288, 143);
+ Add_Goto (Table.States (319), 294, 98);
+ Add_Goto (Table.States (319), 302, 278);
+ Add_Goto (Table.States (319), 321, 145);
+ Add_Goto (Table.States (319), 322, 146);
+ Add_Goto (Table.States (319), 331, 147);
+ Table.States (319).Kernel := To_Vector (((116, 76, 1, False),
(116, 76, 3, False), (200, 76, 1, False),
+ (240, 76, 4, True)));
+ Table.States (319).Minimal_Complete_Actions := To_Vector
(((Reduce, 126, 0), (Reduce, 256, 0)));
Table.States (319).Minimal_Complete_Actions_Recursive := True;
- Table.States (320).Action_List.Set_Capacity (4);
- Add_Action (Table.States (320), (35, 56, 74, 96), (207, 0), 3,
function_specification_0'Access,
+ Table.States (320).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (320), 58, 318);
+ Table.States (320).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (320), 292, 499);
+ Table.States (320).Kernel := To_Vector ((0 => (253, 200, 1,
True)));
+ Table.States (320).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 58, 318)));
+ Table.States (320).Minimal_Complete_Actions_Recursive := True;
+ Table.States (321).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (321), (35, 56, 74, 97), (208, 0), 3,
function_specification_0'Access,
function_specification_0_check'Access);
- Table.States (320).Kernel := To_Vector ((0 => (207, 252, 0,
False)));
- Table.States (320).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 207, 3)));
- Table.States (321).Action_List.Set_Capacity (7);
- Add_Action (Table.States (321), (21, 35, 56, 74, 77, 82, 96),
(252, 1), 1, null, null);
- Table.States (321).Kernel := To_Vector ((0 => (252, 291, 0,
True)));
- Table.States (321).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 252, 1)));
- Table.States (321).Minimal_Complete_Actions_Recursive := True;
- Table.States (322).Action_List.Set_Capacity (5);
- Add_Action (Table.States (322), 56, 497);
- Add_Action (Table.States (322), 76, 235);
- Add_Action (Table.States (322), 84, 237);
- Add_Action (Table.States (322), 101, 239);
- Add_Action (Table.States (322), 102, 240);
- Table.States (322).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (322), 115, 241);
- Add_Goto (Table.States (322), 322, 242);
- Table.States (322).Kernel := To_Vector (((128, 239, 2, True),
(215, 239, 3, False), (239, 239, 5, True),
- (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (322).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 56, 497)));
+ Table.States (321).Kernel := To_Vector ((0 => (208, 253, 0,
False)));
+ Table.States (321).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 208, 3)));
+ Table.States (322).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (322), (21, 35, 56, 74, 77, 83, 97),
(253, 1), 1, null, null);
+ Table.States (322).Kernel := To_Vector ((0 => (253, 292, 0,
True)));
+ Table.States (322).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 253, 1)));
+ Table.States (322).Minimal_Complete_Actions_Recursive := True;
Table.States (323).Action_List.Set_Capacity (5);
- Add_Action (Table.States (323), 56, 498);
- Add_Action (Table.States (323), 76, 235);
- Add_Action (Table.States (323), 84, 237);
- Add_Action (Table.States (323), 101, 239);
+ Add_Action (Table.States (323), 56, 500);
+ Add_Action (Table.States (323), 76, 236);
+ Add_Action (Table.States (323), 85, 238);
Add_Action (Table.States (323), 102, 240);
+ Add_Action (Table.States (323), 103, 241);
Table.States (323).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (323), 115, 241);
- Add_Goto (Table.States (323), 322, 242);
- Table.States (323).Kernel := To_Vector (((128, 239, 2, True),
(215, 239, 3, False), (239, 239, 5, True),
- (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (323).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 56, 498)));
+ Add_Goto (Table.States (323), 116, 242);
+ Add_Goto (Table.States (323), 323, 243);
+ Table.States (323).Kernel := To_Vector (((129, 240, 2, True),
(216, 240, 3, False), (240, 240, 5, True),
+ (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (323).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 56, 500)));
Table.States (324).Action_List.Set_Capacity (5);
- Add_Action (Table.States (324), 56, 499);
- Add_Action (Table.States (324), 76, 235);
- Add_Action (Table.States (324), 84, 237);
- Add_Action (Table.States (324), 101, 239);
+ Add_Action (Table.States (324), 56, 501);
+ Add_Action (Table.States (324), 76, 236);
+ Add_Action (Table.States (324), 85, 238);
Add_Action (Table.States (324), 102, 240);
+ Add_Action (Table.States (324), 103, 241);
Table.States (324).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (324), 115, 241);
- Add_Goto (Table.States (324), 322, 242);
- Table.States (324).Kernel := To_Vector (((128, 239, 2, True),
(215, 239, 3, False), (239, 239, 5, True),
- (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (324).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 56, 499)));
- Table.States (325).Action_List.Set_Capacity (4);
- Add_Action (Table.States (325), 35, Reduce, (169, 2), 0, null,
null);
- Add_Action (Table.States (325), 74, Reduce, (169, 2), 0, null,
null);
- Add_Action (Table.States (325), 76, 377);
- Add_Action (Table.States (325), 96, Reduce, (169, 2), 0, null,
null);
- Table.States (325).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (325), 169, 500);
- Table.States (325).Kernel := To_Vector (((201, 104, 3, False),
(201, 104, 3, False), (201, 104, 1,
+ Add_Goto (Table.States (324), 116, 242);
+ Add_Goto (Table.States (324), 323, 243);
+ Table.States (324).Kernel := To_Vector (((129, 240, 2, True),
(216, 240, 3, False), (240, 240, 5, True),
+ (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (324).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 56, 501)));
+ Table.States (325).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (325), 56, 502);
+ Add_Action (Table.States (325), 76, 236);
+ Add_Action (Table.States (325), 85, 238);
+ Add_Action (Table.States (325), 102, 240);
+ Add_Action (Table.States (325), 103, 241);
+ Table.States (325).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (325), 116, 242);
+ Add_Goto (Table.States (325), 323, 243);
+ Table.States (325).Kernel := To_Vector (((129, 240, 2, True),
(216, 240, 3, False), (240, 240, 5, True),
+ (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (325).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 56, 502)));
+ Table.States (326).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (326), 35, Reduce, (170, 2), 0, null,
null);
+ Add_Action (Table.States (326), 74, Reduce, (170, 2), 0, null,
null);
+ Add_Action (Table.States (326), 76, 378);
+ Add_Action (Table.States (326), 97, Reduce, (170, 2), 0, null,
null);
+ Table.States (326).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (326), 170, 503);
+ Table.States (326).Kernel := To_Vector (((202, 105, 3, False),
(202, 105, 3, False), (202, 105, 1,
False)));
- Table.States (325).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 169, 0)));
- Table.States (326).Action_List.Set_Capacity (3);
- Add_Action (Table.States (326), 104, 119);
- Add_Action (Table.States (326), 105, 33);
- Add_Action (Table.States (326), 106, 34);
- Table.States (326).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (326), 128, 41);
- Add_Goto (Table.States (326), 239, 501);
- Add_Goto (Table.States (326), 272, 92);
- Add_Goto (Table.States (326), 293, 97);
- Table.States (326).Kernel := To_Vector ((0 => (204, 47, 5,
False)));
- Table.States (326).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (327).Action_List.Set_Capacity (3);
- Add_Action (Table.States (327), 35, 502);
- Add_Action (Table.States (327), 74, 337);
- Add_Action (Table.States (327), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (327).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (327), 122, 503);
- Table.States (327).Kernel := To_Vector (((200, 312, 4, False),
(200, 312, 3, False), (200, 312, 3, False),
- (200, 312, 1, False)));
- Table.States (327).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (328).Action_List.Set_Capacity (8);
- Add_Action (Table.States (328), (29, 47, 48, 50, 69, 71, 74, 104),
(211, 0), 2, null, null);
- Table.States (328).Kernel := To_Vector ((0 => (211, 212, 0,
True)));
- Table.States (328).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 211, 2)));
- Table.States (328).Minimal_Complete_Actions_Recursive := True;
- Table.States (329).Action_List.Set_Capacity (10);
- Add_Action (Table.States (329), 7, Reduce, (236, 3), 0, null,
null);
- Add_Action (Table.States (329), 33, 504);
- Add_Action (Table.States (329), 40, Reduce, (236, 3), 0, null,
null);
- Add_Action (Table.States (329), 45, 505);
- Add_Action (Table.States (329), 74, Reduce, (236, 3), 0, null,
null);
- Add_Action (Table.States (329), 82, Reduce, (236, 3), 0, null,
null);
- Add_Action (Table.States (329), 96, Reduce, (236, 3), 0, null,
null);
- Add_Action (Table.States (329), 104, Reduce, (236, 3), 0, null,
null);
- Add_Action (Table.States (329), 105, Reduce, (236, 3), 0, null,
null);
- Add_Action (Table.States (329), 106, Reduce, (236, 3), 0, null,
null);
- Table.States (329).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (329), 236, 506);
- Table.States (329).Kernel := To_Vector (((198, 81, 3, False),
(198, 81, 4, False), (198, 81, 2, False),
- (198, 81, 3, False)));
- Table.States (329).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 236, 0)));
- Table.States (330).Action_List.Set_Capacity (46);
- Add_Action (Table.States (330), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (303, 3), 3, simple_statement_3'Access, null);
- Table.States (330).Kernel := To_Vector ((0 => (303, 96, 0,
False)));
- Table.States (330).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 303, 3)));
- Table.States (331).Action_List.Set_Capacity (25);
- Add_Action (Table.States (331), 4, 1);
- Add_Action (Table.States (331), 5, 2);
- Add_Action (Table.States (331), 13, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (331), 15, 3);
- Add_Action (Table.States (331), 17, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (331), 18, 4);
- Add_Action (Table.States (331), 22, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (331), 23, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (331), 24, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (331), 27, 5);
- Add_Action (Table.States (331), 28, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (331), 31, 9);
- Add_Action (Table.States (331), 32, 10);
- Add_Action (Table.States (331), 37, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (331), 41, 13);
- Add_Action (Table.States (331), 48, 16);
- Add_Action (Table.States (331), 52, 20);
- Add_Action (Table.States (331), 57, 21);
- Add_Action (Table.States (331), 58, 22);
- Add_Action (Table.States (331), 61, 24);
- Add_Action (Table.States (331), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (331), 93, 31);
- Add_Action (Table.States (331), 104, 360);
- Add_Action (Table.States (331), 105, 33);
- Add_Action (Table.States (331), 106, 34);
- Table.States (331).Goto_List.Set_Capacity (31);
- Add_Goto (Table.States (331), 113, 36);
- Add_Goto (Table.States (331), 123, 38);
- Add_Goto (Table.States (331), 126, 39);
- Add_Goto (Table.States (331), 128, 41);
- Add_Goto (Table.States (331), 131, 42);
- Add_Goto (Table.States (331), 132, 43);
- Add_Goto (Table.States (331), 133, 44);
- Add_Goto (Table.States (331), 139, 47);
- Add_Goto (Table.States (331), 151, 50);
- Add_Goto (Table.States (331), 152, 51);
- Add_Goto (Table.States (331), 161, 53);
- Add_Goto (Table.States (331), 190, 57);
- Add_Goto (Table.States (331), 196, 59);
- Add_Goto (Table.States (331), 217, 68);
- Add_Goto (Table.States (331), 222, 70);
- Add_Goto (Table.States (331), 232, 72);
- Add_Goto (Table.States (331), 239, 73);
- Add_Goto (Table.States (331), 257, 83);
- Add_Goto (Table.States (331), 261, 86);
- Add_Goto (Table.States (331), 272, 92);
- Add_Goto (Table.States (331), 276, 93);
- Add_Goto (Table.States (331), 290, 96);
- Add_Goto (Table.States (331), 293, 97);
- Add_Goto (Table.States (331), 294, 98);
- Add_Goto (Table.States (331), 298, 99);
- Add_Goto (Table.States (331), 299, 361);
- Add_Goto (Table.States (331), 300, 507);
- Add_Goto (Table.States (331), 302, 100);
- Add_Goto (Table.States (331), 303, 101);
- Add_Goto (Table.States (331), 306, 363);
- Add_Goto (Table.States (331), 323, 114);
- Table.States (331).Kernel := To_Vector (((222, 68, 6, False),
(222, 68, 4, False), (222, 68, 5, False),
- (222, 68, 3, False)));
- Table.States (331).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 300, 0)));
- Table.States (332).Action_List.Set_Capacity (3);
- Add_Action (Table.States (332), 104, 119);
- Add_Action (Table.States (332), 105, 33);
- Add_Action (Table.States (332), 106, 34);
- Table.States (332).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (332), 128, 41);
- Add_Goto (Table.States (332), 238, 508);
- Add_Goto (Table.States (332), 239, 219);
- Add_Goto (Table.States (332), 272, 92);
- Add_Goto (Table.States (332), 293, 97);
- Table.States (332).Kernel := To_Vector ((0 => (332, 74, 2,
False)));
- Table.States (332).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (333).Action_List.Set_Capacity (2);
- Add_Action (Table.States (333), 83, 381);
- Add_Action (Table.States (333), 96, 509);
- Table.States (333).Kernel := To_Vector (((238, 238, 2, True),
(332, 238, 1, False)));
- Table.States (333).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 509)));
- Table.States (334).Action_List.Set_Capacity (6);
- Add_Action (Table.States (334), 35, 510);
- Add_Conflict (Table.States (334), 35, (122, 1), 0, null, null);
- Add_Action (Table.States (334), 74, 337);
- Add_Action (Table.States (334), 76, 235);
- Add_Action (Table.States (334), 84, 237);
- Add_Action (Table.States (334), 101, 239);
- Add_Action (Table.States (334), 102, 240);
- Table.States (334).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (334), 115, 241);
- Add_Goto (Table.States (334), 122, 511);
- Add_Goto (Table.States (334), 322, 242);
- Table.States (334).Kernel := To_Vector (((128, 239, 2, True),
(239, 239, 5, True), (239, 239, 2, True),
- (247, 239, 4, False), (247, 239, 3, False), (248, 239, 3, False),
(272, 239, 3, True), (293, 239, 2, True),
- (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True)));
- Table.States (334).Minimal_Complete_Actions := To_Vector
(((Reduce, 122, 0), (Shift, 35, 510)));
+ Table.States (326).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 170, 0)));
+ Table.States (327).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (327), 79, 31);
+ Add_Action (Table.States (327), 105, 120);
+ Add_Action (Table.States (327), 106, 34);
+ Add_Action (Table.States (327), 107, 35);
+ Table.States (327).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (327), 129, 42);
+ Add_Goto (Table.States (327), 240, 504);
+ Add_Goto (Table.States (327), 273, 93);
+ Add_Goto (Table.States (327), 294, 98);
+ Table.States (327).Kernel := To_Vector ((0 => (205, 47, 5,
False)));
+ Table.States (327).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (328).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (328), 35, 505);
+ Add_Action (Table.States (328), 74, 338);
+ Add_Action (Table.States (328), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (328).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (328), 123, 506);
+ Table.States (328).Kernel := To_Vector (((201, 313, 4, False),
(201, 313, 3, False), (201, 313, 3, False),
+ (201, 313, 1, False)));
+ Table.States (328).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (329).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (329), (29, 47, 48, 50, 69, 71, 74, 105),
(212, 0), 2, null, null);
+ Table.States (329).Kernel := To_Vector ((0 => (212, 213, 0,
True)));
+ Table.States (329).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 212, 2)));
+ Table.States (329).Minimal_Complete_Actions_Recursive := True;
+ Table.States (330).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (330), 7, Reduce, (237, 3), 0, null,
null);
+ Add_Action (Table.States (330), 33, 507);
+ Add_Action (Table.States (330), 40, Reduce, (237, 3), 0, null,
null);
+ Add_Action (Table.States (330), 45, 508);
+ Add_Action (Table.States (330), 74, Reduce, (237, 3), 0, null,
null);
+ Add_Action (Table.States (330), 79, Reduce, (237, 3), 0, null,
null);
+ Add_Action (Table.States (330), 83, Reduce, (237, 3), 0, null,
null);
+ Add_Action (Table.States (330), 97, Reduce, (237, 3), 0, null,
null);
+ Add_Action (Table.States (330), 105, Reduce, (237, 3), 0, null,
null);
+ Add_Action (Table.States (330), 106, Reduce, (237, 3), 0, null,
null);
+ Add_Action (Table.States (330), 107, Reduce, (237, 3), 0, null,
null);
+ Table.States (330).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (330), 237, 509);
+ Table.States (330).Kernel := To_Vector (((199, 82, 3, False),
(199, 82, 4, False), (199, 82, 2, False),
+ (199, 82, 3, False)));
+ Table.States (330).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 237, 0)));
end Subr_6;
procedure Subr_7
is begin
- Table.States (335).Action_List.Set_Capacity (1);
- Add_Action (Table.States (335), 39, 512);
- Table.States (335).Kernel := To_Vector ((0 => (213, 35, 3,
False)));
- Table.States (335).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 39, 512)));
- Table.States (336).Action_List.Set_Capacity (3);
- Add_Action (Table.States (336), 104, 119);
- Add_Action (Table.States (336), 105, 33);
- Add_Action (Table.States (336), 106, 34);
- Table.States (336).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (336), 128, 41);
- Add_Goto (Table.States (336), 239, 513);
- Add_Goto (Table.States (336), 272, 92);
- Add_Goto (Table.States (336), 293, 97);
- Table.States (336).Kernel := To_Vector ((0 => (250, 56, 2,
False)));
- Table.States (336).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (337).Action_List.Set_Capacity (18);
- Add_Action (Table.States (337), 3, 121);
- Add_Action (Table.States (337), 35, Reduce, (124, 5), 0, null,
null);
- Add_Action (Table.States (337), 39, 122);
- Add_Action (Table.States (337), 40, 261);
- Add_Action (Table.States (337), 41, 124);
- Add_Action (Table.States (337), 44, 263);
- Add_Action (Table.States (337), 52, 125);
- Add_Action (Table.States (337), 76, 126);
- Add_Action (Table.States (337), 79, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (337), 83, Reduce, (124, 5), 0, null,
null);
- Add_Action (Table.States (337), 87, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (337), 94, 127);
- Add_Action (Table.States (337), 95, 128);
- Add_Action (Table.States (337), 96, Reduce, (124, 5), 0, null,
null);
- Add_Action (Table.States (337), 103, 129);
- Add_Action (Table.States (337), 104, 119);
- Add_Action (Table.States (337), 105, 33);
- Add_Action (Table.States (337), 106, 264);
- Table.States (337).Goto_List.Set_Capacity (24);
- Add_Goto (Table.States (337), 117, 130);
- Add_Goto (Table.States (337), 124, 265);
- Add_Goto (Table.States (337), 125, 514);
- Add_Goto (Table.States (337), 128, 41);
- Add_Goto (Table.States (337), 165, 269);
- Add_Goto (Table.States (337), 166, 270);
- Add_Goto (Table.States (337), 191, 408);
- Add_Goto (Table.States (337), 197, 133);
- Add_Goto (Table.States (337), 239, 274);
- Add_Goto (Table.States (337), 258, 135);
- Add_Goto (Table.States (337), 272, 92);
- Add_Goto (Table.States (337), 275, 136);
- Add_Goto (Table.States (337), 277, 276);
- Add_Goto (Table.States (337), 282, 137);
- Add_Goto (Table.States (337), 283, 138);
- Add_Goto (Table.States (337), 284, 139);
- Add_Goto (Table.States (337), 285, 140);
- Add_Goto (Table.States (337), 286, 141);
- Add_Goto (Table.States (337), 287, 142);
- Add_Goto (Table.States (337), 293, 97);
- Add_Goto (Table.States (337), 301, 277);
- Add_Goto (Table.States (337), 320, 144);
- Add_Goto (Table.States (337), 321, 145);
- Add_Goto (Table.States (337), 330, 146);
- Table.States (337).Kernel := To_Vector ((0 => (122, 74, 0,
False)));
- Table.States (337).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 125, 0)));
- Table.States (338).Action_List.Set_Capacity (1);
- Add_Action (Table.States (338), 35, 515);
- Table.States (338).Kernel := To_Vector (((251, 122, 3, False),
(251, 122, 2, False)));
- Table.States (338).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 515)));
- Table.States (339).Action_List.Set_Capacity (20);
- Add_Action (Table.States (339), 3, 121);
- Add_Action (Table.States (339), 15, 258);
- Add_Action (Table.States (339), 28, 259);
- Add_Action (Table.States (339), 32, 260);
- Add_Action (Table.States (339), 39, 122);
- Add_Action (Table.States (339), 40, 261);
- Add_Action (Table.States (339), 41, 124);
- Add_Action (Table.States (339), 44, 263);
- Add_Action (Table.States (339), 52, 125);
- Add_Action (Table.States (339), 76, 126);
- Add_Action (Table.States (339), 77, Reduce, (124, 5), 0, null,
null);
- Add_Action (Table.States (339), 79, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (339), 83, Reduce, (124, 5), 0, null,
null);
- Add_Action (Table.States (339), 87, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (339), 94, 127);
- Add_Action (Table.States (339), 95, 128);
- Add_Action (Table.States (339), 103, 129);
- Add_Action (Table.States (339), 104, 119);
- Add_Action (Table.States (339), 105, 33);
- Add_Action (Table.States (339), 106, 264);
- Table.States (339).Goto_List.Set_Capacity (28);
- Add_Goto (Table.States (339), 117, 130);
- Add_Goto (Table.States (339), 124, 265);
- Add_Goto (Table.States (339), 125, 516);
- Add_Goto (Table.States (339), 128, 41);
- Add_Goto (Table.States (339), 136, 267);
- Add_Goto (Table.States (339), 153, 517);
- Add_Goto (Table.States (339), 165, 269);
- Add_Goto (Table.States (339), 166, 270);
- Add_Goto (Table.States (339), 191, 408);
- Add_Goto (Table.States (339), 197, 133);
- Add_Goto (Table.States (339), 221, 273);
- Add_Goto (Table.States (339), 239, 274);
- Add_Goto (Table.States (339), 258, 135);
- Add_Goto (Table.States (339), 272, 92);
- Add_Goto (Table.States (339), 273, 275);
- Add_Goto (Table.States (339), 275, 136);
- Add_Goto (Table.States (339), 277, 276);
- Add_Goto (Table.States (339), 282, 137);
- Add_Goto (Table.States (339), 283, 138);
- Add_Goto (Table.States (339), 284, 139);
- Add_Goto (Table.States (339), 285, 140);
- Add_Goto (Table.States (339), 286, 141);
- Add_Goto (Table.States (339), 287, 142);
- Add_Goto (Table.States (339), 293, 97);
- Add_Goto (Table.States (339), 301, 277);
- Add_Goto (Table.States (339), 320, 144);
- Add_Goto (Table.States (339), 321, 145);
- Add_Goto (Table.States (339), 330, 146);
- Table.States (339).Kernel := To_Vector (((257, 76, 2, False),
(257, 76, 4, False)));
- Table.States (339).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 125, 0)));
- Table.States (340).Action_List.Set_Capacity (46);
- Add_Action (Table.States (340), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (257, 2), 3, pragma_g_2'Access, null);
- Table.States (340).Kernel := To_Vector ((0 => (257, 96, 0,
False)));
- Table.States (340).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 257, 3)));
- Table.States (341).Action_List.Set_Capacity (5);
- Add_Action (Table.States (341), 71, Reduce, (163, 0), 1, null,
null);
- Add_Conflict (Table.States (341), 71, (239, 5), 1, name_5'Access,
name_5_check'Access);
- Add_Action (Table.States (341), 76, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (341), 84, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (341), 101, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (341), 102, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Table.States (341).Kernel := To_Vector (((163, 104, 0, False),
(239, 104, 0, False)));
- Table.States (341).Minimal_Complete_Actions := To_Vector
(((Reduce, 163, 1), (Reduce, 239, 1)));
- Table.States (342).Action_List.Set_Capacity (2);
- Add_Action (Table.States (342), 83, 381);
- Add_Action (Table.States (342), 96, 518);
- Table.States (342).Kernel := To_Vector (((238, 238, 2, True),
(332, 238, 1, False)));
- Table.States (342).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 518)));
- Table.States (343).Action_List.Set_Capacity (6);
- Add_Action (Table.States (343), 7, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (343), 26, 385);
- Add_Action (Table.States (343), 40, 386);
- Add_Action (Table.States (343), 104, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (343), 105, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (343), 106, Reduce, (241, 1), 0, null,
null);
- Table.States (343).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (343), 114, 387);
- Add_Goto (Table.States (343), 241, 388);
- Table.States (343).Kernel := To_Vector (((245, 81, 4, False),
(245, 81, 5, False), (245, 81, 4, False)));
- Table.States (343).Minimal_Complete_Actions := To_Vector
(((Reduce, 241, 0), (Shift, 26, 385)));
- Table.States (344).Action_List.Set_Capacity (8);
- Add_Action (Table.States (344), (21, 35, 56, 72, 74, 77, 82, 96),
(253, 0), 1, null, null);
- Table.States (344).Kernel := To_Vector ((0 => (253, 199, 0,
False)));
- Table.States (344).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 253, 1)));
- Table.States (345).Action_List.Set_Capacity (4);
- Add_Action (Table.States (345), (35, 56, 74, 96), (262, 0), 3,
procedure_specification_0'Access,
+ Table.States (331).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (331), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (304, 3), 3, simple_statement_3'Access, null);
+ Table.States (331).Kernel := To_Vector ((0 => (304, 97, 0,
False)));
+ Table.States (331).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 304, 3)));
+ Table.States (332).Action_List.Set_Capacity (26);
+ Add_Action (Table.States (332), 4, 1);
+ Add_Action (Table.States (332), 5, 2);
+ Add_Action (Table.States (332), 13, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (332), 15, 3);
+ Add_Action (Table.States (332), 17, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (332), 18, 4);
+ Add_Action (Table.States (332), 22, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (332), 23, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (332), 24, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (332), 27, 5);
+ Add_Action (Table.States (332), 28, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (332), 31, 9);
+ Add_Action (Table.States (332), 32, 10);
+ Add_Action (Table.States (332), 37, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (332), 41, 13);
+ Add_Action (Table.States (332), 48, 16);
+ Add_Action (Table.States (332), 52, 20);
+ Add_Action (Table.States (332), 57, 21);
+ Add_Action (Table.States (332), 58, 22);
+ Add_Action (Table.States (332), 61, 24);
+ Add_Action (Table.States (332), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (332), 79, 31);
+ Add_Action (Table.States (332), 94, 32);
+ Add_Action (Table.States (332), 105, 361);
+ Add_Action (Table.States (332), 106, 34);
+ Add_Action (Table.States (332), 107, 35);
+ Table.States (332).Goto_List.Set_Capacity (31);
+ Add_Goto (Table.States (332), 114, 37);
+ Add_Goto (Table.States (332), 124, 39);
+ Add_Goto (Table.States (332), 127, 40);
+ Add_Goto (Table.States (332), 129, 42);
+ Add_Goto (Table.States (332), 132, 43);
+ Add_Goto (Table.States (332), 133, 44);
+ Add_Goto (Table.States (332), 134, 45);
+ Add_Goto (Table.States (332), 140, 48);
+ Add_Goto (Table.States (332), 152, 51);
+ Add_Goto (Table.States (332), 153, 52);
+ Add_Goto (Table.States (332), 162, 54);
+ Add_Goto (Table.States (332), 191, 58);
+ Add_Goto (Table.States (332), 197, 60);
+ Add_Goto (Table.States (332), 218, 69);
+ Add_Goto (Table.States (332), 223, 71);
+ Add_Goto (Table.States (332), 233, 73);
+ Add_Goto (Table.States (332), 240, 74);
+ Add_Goto (Table.States (332), 258, 84);
+ Add_Goto (Table.States (332), 262, 87);
+ Add_Goto (Table.States (332), 273, 93);
+ Add_Goto (Table.States (332), 277, 94);
+ Add_Goto (Table.States (332), 291, 97);
+ Add_Goto (Table.States (332), 294, 98);
+ Add_Goto (Table.States (332), 295, 99);
+ Add_Goto (Table.States (332), 299, 100);
+ Add_Goto (Table.States (332), 300, 362);
+ Add_Goto (Table.States (332), 301, 510);
+ Add_Goto (Table.States (332), 303, 101);
+ Add_Goto (Table.States (332), 304, 102);
+ Add_Goto (Table.States (332), 307, 364);
+ Add_Goto (Table.States (332), 324, 115);
+ Table.States (332).Kernel := To_Vector (((223, 68, 6, False),
(223, 68, 4, False), (223, 68, 5, False),
+ (223, 68, 3, False)));
+ Table.States (332).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 301, 0)));
+ Table.States (333).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (333), 79, 31);
+ Add_Action (Table.States (333), 105, 120);
+ Add_Action (Table.States (333), 106, 34);
+ Add_Action (Table.States (333), 107, 35);
+ Table.States (333).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (333), 129, 42);
+ Add_Goto (Table.States (333), 239, 511);
+ Add_Goto (Table.States (333), 240, 220);
+ Add_Goto (Table.States (333), 273, 93);
+ Add_Goto (Table.States (333), 294, 98);
+ Table.States (333).Kernel := To_Vector ((0 => (333, 74, 2,
False)));
+ Table.States (333).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (334).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (334), 84, 382);
+ Add_Action (Table.States (334), 97, 512);
+ Table.States (334).Kernel := To_Vector (((239, 239, 2, True),
(333, 239, 1, False)));
+ Table.States (334).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 512)));
+ Table.States (335).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (335), 35, 513);
+ Add_Conflict (Table.States (335), 35, (123, 1), 0, null, null);
+ Add_Action (Table.States (335), 74, 338);
+ Add_Action (Table.States (335), 76, 236);
+ Add_Action (Table.States (335), 85, 238);
+ Add_Action (Table.States (335), 102, 240);
+ Add_Action (Table.States (335), 103, 241);
+ Table.States (335).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (335), 116, 242);
+ Add_Goto (Table.States (335), 123, 514);
+ Add_Goto (Table.States (335), 323, 243);
+ Table.States (335).Kernel := To_Vector (((129, 240, 2, True),
(240, 240, 5, True), (240, 240, 2, True),
+ (248, 240, 4, False), (248, 240, 3, False), (249, 240, 3, False),
(273, 240, 3, True), (294, 240, 2, True),
+ (294, 240, 2, True), (294, 240, 2, True), (294, 240, 2, True)));
+ Table.States (335).Minimal_Complete_Actions := To_Vector
(((Reduce, 123, 0), (Shift, 35, 513)));
+ Table.States (336).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (336), 39, 515);
+ Table.States (336).Kernel := To_Vector ((0 => (214, 35, 3,
False)));
+ Table.States (336).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 39, 515)));
+ Table.States (337).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (337), 79, 31);
+ Add_Action (Table.States (337), 105, 120);
+ Add_Action (Table.States (337), 106, 34);
+ Add_Action (Table.States (337), 107, 35);
+ Table.States (337).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (337), 129, 42);
+ Add_Goto (Table.States (337), 240, 516);
+ Add_Goto (Table.States (337), 273, 93);
+ Add_Goto (Table.States (337), 294, 98);
+ Table.States (337).Kernel := To_Vector ((0 => (251, 56, 2,
False)));
+ Table.States (337).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (338).Action_List.Set_Capacity (20);
+ Add_Action (Table.States (338), 3, 122);
+ Add_Action (Table.States (338), 28, 517);
+ Add_Action (Table.States (338), 35, Reduce, (125, 6), 0, null,
null);
+ Add_Action (Table.States (338), 39, 123);
+ Add_Action (Table.States (338), 40, 262);
+ Add_Action (Table.States (338), 41, 125);
+ Add_Action (Table.States (338), 44, 264);
+ Add_Action (Table.States (338), 52, 126);
+ Add_Action (Table.States (338), 76, 127);
+ Add_Action (Table.States (338), 79, 31);
+ Add_Action (Table.States (338), 80, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (338), 84, Reduce, (125, 6), 0, null,
null);
+ Add_Action (Table.States (338), 88, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (338), 95, 128);
+ Add_Action (Table.States (338), 96, 129);
+ Add_Action (Table.States (338), 97, Reduce, (125, 6), 0, null,
null);
+ Add_Action (Table.States (338), 104, 130);
+ Add_Action (Table.States (338), 105, 120);
+ Add_Action (Table.States (338), 106, 34);
+ Add_Action (Table.States (338), 107, 265);
+ Table.States (338).Goto_List.Set_Capacity (24);
+ Add_Goto (Table.States (338), 118, 131);
+ Add_Goto (Table.States (338), 125, 266);
+ Add_Goto (Table.States (338), 126, 518);
+ Add_Goto (Table.States (338), 129, 42);
+ Add_Goto (Table.States (338), 166, 270);
+ Add_Goto (Table.States (338), 167, 271);
+ Add_Goto (Table.States (338), 192, 409);
+ Add_Goto (Table.States (338), 198, 134);
+ Add_Goto (Table.States (338), 240, 275);
+ Add_Goto (Table.States (338), 259, 136);
+ Add_Goto (Table.States (338), 273, 93);
+ Add_Goto (Table.States (338), 276, 137);
+ Add_Goto (Table.States (338), 278, 277);
+ Add_Goto (Table.States (338), 283, 138);
+ Add_Goto (Table.States (338), 284, 139);
+ Add_Goto (Table.States (338), 285, 140);
+ Add_Goto (Table.States (338), 286, 141);
+ Add_Goto (Table.States (338), 287, 142);
+ Add_Goto (Table.States (338), 288, 143);
+ Add_Goto (Table.States (338), 294, 98);
+ Add_Goto (Table.States (338), 302, 278);
+ Add_Goto (Table.States (338), 321, 145);
+ Add_Goto (Table.States (338), 322, 146);
+ Add_Goto (Table.States (338), 331, 147);
+ Table.States (338).Kernel := To_Vector ((0 => (123, 74, 0,
False)));
+ Table.States (338).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 126, 0)));
+ Table.States (339).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (339), 35, 519);
+ Table.States (339).Kernel := To_Vector (((252, 123, 3, False),
(252, 123, 2, False)));
+ Table.States (339).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 519)));
+ Table.States (340).Action_List.Set_Capacity (21);
+ Add_Action (Table.States (340), 3, 122);
+ Add_Action (Table.States (340), 15, 259);
+ Add_Action (Table.States (340), 28, 260);
+ Add_Action (Table.States (340), 32, 261);
+ Add_Action (Table.States (340), 39, 123);
+ Add_Action (Table.States (340), 40, 262);
+ Add_Action (Table.States (340), 41, 125);
+ Add_Action (Table.States (340), 44, 264);
+ Add_Action (Table.States (340), 52, 126);
+ Add_Action (Table.States (340), 76, 127);
+ Add_Action (Table.States (340), 77, Reduce, (125, 6), 0, null,
null);
+ Add_Action (Table.States (340), 79, 31);
+ Add_Action (Table.States (340), 80, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (340), 84, Reduce, (125, 6), 0, null,
null);
+ Add_Action (Table.States (340), 88, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (340), 95, 128);
+ Add_Action (Table.States (340), 96, 129);
+ Add_Action (Table.States (340), 104, 130);
+ Add_Action (Table.States (340), 105, 120);
+ Add_Action (Table.States (340), 106, 34);
+ Add_Action (Table.States (340), 107, 265);
+ Table.States (340).Goto_List.Set_Capacity (28);
+ Add_Goto (Table.States (340), 118, 131);
+ Add_Goto (Table.States (340), 125, 266);
+ Add_Goto (Table.States (340), 126, 520);
+ Add_Goto (Table.States (340), 129, 42);
+ Add_Goto (Table.States (340), 137, 268);
+ Add_Goto (Table.States (340), 154, 521);
+ Add_Goto (Table.States (340), 166, 270);
+ Add_Goto (Table.States (340), 167, 271);
+ Add_Goto (Table.States (340), 192, 409);
+ Add_Goto (Table.States (340), 198, 134);
+ Add_Goto (Table.States (340), 222, 274);
+ Add_Goto (Table.States (340), 240, 275);
+ Add_Goto (Table.States (340), 259, 136);
+ Add_Goto (Table.States (340), 273, 93);
+ Add_Goto (Table.States (340), 274, 276);
+ Add_Goto (Table.States (340), 276, 137);
+ Add_Goto (Table.States (340), 278, 277);
+ Add_Goto (Table.States (340), 283, 138);
+ Add_Goto (Table.States (340), 284, 139);
+ Add_Goto (Table.States (340), 285, 140);
+ Add_Goto (Table.States (340), 286, 141);
+ Add_Goto (Table.States (340), 287, 142);
+ Add_Goto (Table.States (340), 288, 143);
+ Add_Goto (Table.States (340), 294, 98);
+ Add_Goto (Table.States (340), 302, 278);
+ Add_Goto (Table.States (340), 321, 145);
+ Add_Goto (Table.States (340), 322, 146);
+ Add_Goto (Table.States (340), 331, 147);
+ Table.States (340).Kernel := To_Vector (((258, 76, 2, False),
(258, 76, 4, False)));
+ Table.States (340).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 126, 0)));
+ Table.States (341).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (341), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (258, 2), 3, pragma_g_2'Access, null);
+ Table.States (341).Kernel := To_Vector ((0 => (258, 97, 0,
False)));
+ Table.States (341).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 258, 3)));
+ Table.States (342).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (342), 71, Reduce, (164, 0), 1, null,
null);
+ Add_Conflict (Table.States (342), 71, (240, 5), 1, name_5'Access,
name_5_check'Access);
+ Add_Action (Table.States (342), 76, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (342), 85, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (342), 102, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (342), 103, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Table.States (342).Kernel := To_Vector (((164, 105, 0, False),
(240, 105, 0, False)));
+ Table.States (342).Minimal_Complete_Actions := To_Vector
(((Reduce, 164, 1), (Reduce, 240, 1)));
+ Table.States (343).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (343), 84, 382);
+ Add_Action (Table.States (343), 97, 522);
+ Table.States (343).Kernel := To_Vector (((239, 239, 2, True),
(333, 239, 1, False)));
+ Table.States (343).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 522)));
+ Table.States (344).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (344), 7, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (344), 26, 386);
+ Add_Action (Table.States (344), 40, 387);
+ Add_Action (Table.States (344), 79, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (344), 105, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (344), 106, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (344), 107, Reduce, (242, 1), 0, null,
null);
+ Table.States (344).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (344), 115, 388);
+ Add_Goto (Table.States (344), 242, 389);
+ Table.States (344).Kernel := To_Vector (((246, 82, 4, False),
(246, 82, 5, False), (246, 82, 4, False)));
+ Table.States (344).Minimal_Complete_Actions := To_Vector
(((Reduce, 242, 0), (Shift, 26, 386)));
+ Table.States (345).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (345), (21, 35, 56, 72, 74, 77, 83, 97),
(254, 0), 1, null, null);
+ Table.States (345).Kernel := To_Vector ((0 => (254, 200, 0,
False)));
+ Table.States (345).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 254, 1)));
+ Table.States (346).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (346), (35, 56, 74, 97), (263, 0), 3,
procedure_specification_0'Access,
procedure_specification_0_check'Access);
- Table.States (345).Kernel := To_Vector ((0 => (262, 253, 0,
False)));
- Table.States (345).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 262, 3)));
- Table.States (346).Action_List.Set_Capacity (2);
- Add_Action (Table.States (346), 35, 519);
- Add_Conflict (Table.States (346), 35, (122, 1), 0, null, null);
- Add_Action (Table.States (346), 74, 337);
- Table.States (346).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (346), 122, 520);
- Table.States (346).Kernel := To_Vector (((264, 104, 3, False),
(265, 104, 3, False)));
- Table.States (346).Minimal_Complete_Actions := To_Vector
(((Reduce, 122, 0), (Shift, 35, 519)));
- Table.States (347).Action_List.Set_Capacity (3);
- Add_Action (Table.States (347), 35, Reduce, (169, 2), 0, null,
null);
- Add_Action (Table.States (347), 74, Reduce, (169, 2), 0, null,
null);
- Add_Action (Table.States (347), 76, 377);
+ Table.States (346).Kernel := To_Vector ((0 => (263, 254, 0,
False)));
+ Table.States (346).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 263, 3)));
+ Table.States (347).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (347), 35, 523);
+ Add_Conflict (Table.States (347), 35, (123, 1), 0, null, null);
+ Add_Action (Table.States (347), 74, 338);
Table.States (347).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (347), 169, 521);
- Table.States (347).Kernel := To_Vector (((271, 104, 6, False),
(271, 104, 3, False)));
- Table.States (347).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 169, 0)));
- Table.States (348).Action_List.Set_Capacity (1);
- Add_Action (Table.States (348), 35, 522);
- Table.States (348).Kernel := To_Vector (((304, 122, 6, False),
(304, 122, 3, False)));
- Table.States (348).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 522)));
- Table.States (349).Action_List.Set_Capacity (13);
- Add_Action (Table.States (349), 3, 121);
- Add_Action (Table.States (349), 39, 122);
- Add_Action (Table.States (349), 40, 123);
- Add_Action (Table.States (349), 41, 124);
- Add_Action (Table.States (349), 52, 125);
- Add_Action (Table.States (349), 76, 126);
- Add_Action (Table.States (349), 94, 127);
- Add_Action (Table.States (349), 95, 128);
- Add_Action (Table.States (349), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (349), 103, 129);
- Add_Action (Table.States (349), 104, 119);
- Add_Action (Table.States (349), 105, 33);
- Add_Action (Table.States (349), 106, 34);
- Table.States (349).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (349), 117, 130);
- Add_Goto (Table.States (349), 128, 41);
- Add_Goto (Table.States (349), 191, 131);
- Add_Goto (Table.States (349), 192, 523);
- Add_Goto (Table.States (349), 197, 133);
- Add_Goto (Table.States (349), 239, 134);
- Add_Goto (Table.States (349), 258, 135);
- Add_Goto (Table.States (349), 272, 92);
- Add_Goto (Table.States (349), 275, 136);
- Add_Goto (Table.States (349), 282, 137);
- Add_Goto (Table.States (349), 283, 138);
- Add_Goto (Table.States (349), 284, 139);
- Add_Goto (Table.States (349), 285, 140);
- Add_Goto (Table.States (349), 286, 141);
- Add_Goto (Table.States (349), 287, 142);
- Add_Goto (Table.States (349), 293, 97);
- Add_Goto (Table.States (349), 301, 143);
- Add_Goto (Table.States (349), 320, 144);
- Add_Goto (Table.States (349), 321, 145);
- Add_Goto (Table.States (349), 330, 146);
- Table.States (349).Kernel := To_Vector ((0 => (276, 74, 1,
False)));
- Table.States (349).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (350).Action_List.Set_Capacity (46);
- Add_Action (Table.States (350), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (276, 1), 3, raise_statement_1'Access, null);
- Table.States (350).Kernel := To_Vector ((0 => (276, 96, 0,
False)));
- Table.States (350).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 276, 3)));
- Table.States (351).Action_List.Set_Capacity (1);
- Add_Action (Table.States (351), 5, 524);
- Table.States (351).Kernel := To_Vector ((0 => (290, 74, 2,
False)));
- Table.States (351).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 5, 524)));
- Table.States (352).Action_List.Set_Capacity (46);
- Add_Action (Table.States (352), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (290, 1), 3, requeue_statement_1'Access, null);
- Table.States (352).Kernel := To_Vector ((0 => (290, 96, 0,
False)));
- Table.States (352).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 290, 3)));
- Table.States (353).Action_List.Set_Capacity (10);
- Add_Action (Table.States (353), 7, Reduce, (118, 1), 0, null,
null);
- Add_Action (Table.States (353), 8, 401);
- Add_Action (Table.States (353), 16, Reduce, (118, 1), 0, null,
null);
- Add_Action (Table.States (353), 21, Reduce, (118, 1), 0, null,
null);
- Add_Action (Table.States (353), 40, Reduce, (118, 1), 0, null,
null);
- Add_Action (Table.States (353), 82, Reduce, (118, 1), 0, null,
null);
- Add_Action (Table.States (353), 96, Reduce, (118, 1), 0, null,
null);
- Add_Action (Table.States (353), 104, Reduce, (118, 1), 0, null,
null);
- Add_Action (Table.States (353), 105, Reduce, (118, 1), 0, null,
null);
- Add_Action (Table.States (353), 106, Reduce, (118, 1), 0, null,
null);
- Table.States (353).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (353), 118, 525);
- Table.States (353).Kernel := To_Vector (((194, 81, 2, False),
(194, 81, 1, False)));
- Table.States (353).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 118, 0)));
- Table.States (354).Action_List.Set_Capacity (46);
- Add_Action (Table.States (354), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (302, 0), 3, simple_return_statement_0'Access, null);
- Table.States (354).Kernel := To_Vector ((0 => (302, 96, 0,
False)));
- Table.States (354).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 302, 3)));
- Table.States (355).Action_List.Set_Capacity (46);
+ Add_Goto (Table.States (347), 123, 524);
+ Table.States (347).Kernel := To_Vector (((265, 105, 3, False),
(266, 105, 3, False)));
+ Table.States (347).Minimal_Complete_Actions := To_Vector
(((Reduce, 123, 0), (Shift, 35, 523)));
+ Table.States (348).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (348), 35, Reduce, (170, 2), 0, null,
null);
+ Add_Action (Table.States (348), 74, Reduce, (170, 2), 0, null,
null);
+ Add_Action (Table.States (348), 76, 378);
+ Table.States (348).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (348), 170, 525);
+ Table.States (348).Kernel := To_Vector (((272, 105, 6, False),
(272, 105, 3, False)));
+ Table.States (348).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 170, 0)));
+ Table.States (349).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (349), 35, 526);
+ Table.States (349).Kernel := To_Vector (((305, 123, 6, False),
(305, 123, 3, False)));
+ Table.States (349).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 526)));
+ Table.States (350).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (350), 3, 122);
+ Add_Action (Table.States (350), 39, 123);
+ Add_Action (Table.States (350), 40, 124);
+ Add_Action (Table.States (350), 41, 125);
+ Add_Action (Table.States (350), 52, 126);
+ Add_Action (Table.States (350), 76, 127);
+ Add_Action (Table.States (350), 79, 31);
+ Add_Action (Table.States (350), 95, 128);
+ Add_Action (Table.States (350), 96, 129);
+ Add_Action (Table.States (350), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (350), 104, 130);
+ Add_Action (Table.States (350), 105, 120);
+ Add_Action (Table.States (350), 106, 34);
+ Add_Action (Table.States (350), 107, 35);
+ Table.States (350).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (350), 118, 131);
+ Add_Goto (Table.States (350), 129, 42);
+ Add_Goto (Table.States (350), 192, 132);
+ Add_Goto (Table.States (350), 193, 527);
+ Add_Goto (Table.States (350), 198, 134);
+ Add_Goto (Table.States (350), 240, 135);
+ Add_Goto (Table.States (350), 259, 136);
+ Add_Goto (Table.States (350), 273, 93);
+ Add_Goto (Table.States (350), 276, 137);
+ Add_Goto (Table.States (350), 283, 138);
+ Add_Goto (Table.States (350), 284, 139);
+ Add_Goto (Table.States (350), 285, 140);
+ Add_Goto (Table.States (350), 286, 141);
+ Add_Goto (Table.States (350), 287, 142);
+ Add_Goto (Table.States (350), 288, 143);
+ Add_Goto (Table.States (350), 294, 98);
+ Add_Goto (Table.States (350), 302, 144);
+ Add_Goto (Table.States (350), 321, 145);
+ Add_Goto (Table.States (350), 322, 146);
+ Add_Goto (Table.States (350), 331, 147);
+ Table.States (350).Kernel := To_Vector ((0 => (277, 74, 1,
False)));
+ Table.States (350).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (351).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (351), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (277, 1), 3, raise_statement_1'Access, null);
+ Table.States (351).Kernel := To_Vector ((0 => (277, 97, 0,
False)));
+ Table.States (351).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 277, 3)));
+ Table.States (352).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (352), 5, 528);
+ Table.States (352).Kernel := To_Vector ((0 => (291, 74, 2,
False)));
+ Table.States (352).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 5, 528)));
+ Table.States (353).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (353), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (291, 1), 3, requeue_statement_1'Access, null);
+ Table.States (353).Kernel := To_Vector ((0 => (291, 97, 0,
False)));
+ Table.States (353).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 291, 3)));
+ Table.States (354).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (354), 7, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (354), 8, 402);
+ Add_Action (Table.States (354), 16, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (354), 21, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (354), 40, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (354), 79, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (354), 83, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (354), 97, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (354), 105, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (354), 106, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (354), 107, Reduce, (119, 1), 0, null,
null);
+ Table.States (354).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (354), 119, 529);
+ Table.States (354).Kernel := To_Vector (((195, 82, 2, False),
(195, 82, 1, False)));
+ Table.States (354).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 119, 0)));
+ Table.States (355).Action_List.Set_Capacity (47);
Add_Action (Table.States (355), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (196, 1), 3, extended_return_statement_1'Access, null);
- Table.States (355).Kernel := To_Vector ((0 => (196, 96, 0,
False)));
- Table.States (355).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 196, 3)));
- Table.States (356).Action_List.Set_Capacity (24);
- Add_Action (Table.States (356), 4, 1);
- Add_Action (Table.States (356), 5, 2);
- Add_Action (Table.States (356), 13, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (356), 15, 3);
- Add_Action (Table.States (356), 17, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (356), 18, 4);
- Add_Action (Table.States (356), 24, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (356), 26, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (356), 27, 5);
- Add_Action (Table.States (356), 28, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (356), 31, 9);
- Add_Action (Table.States (356), 32, 10);
- Add_Action (Table.States (356), 37, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (356), 41, 13);
- Add_Action (Table.States (356), 48, 16);
- Add_Action (Table.States (356), 52, 20);
- Add_Action (Table.States (356), 57, 21);
- Add_Action (Table.States (356), 58, 22);
- Add_Action (Table.States (356), 61, 24);
- Add_Action (Table.States (356), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (356), 93, 31);
- Add_Action (Table.States (356), 104, 360);
- Add_Action (Table.States (356), 105, 33);
- Add_Action (Table.States (356), 106, 34);
- Table.States (356).Goto_List.Set_Capacity (32);
- Add_Goto (Table.States (356), 113, 36);
- Add_Goto (Table.States (356), 123, 38);
- Add_Goto (Table.States (356), 126, 39);
- Add_Goto (Table.States (356), 128, 41);
- Add_Goto (Table.States (356), 131, 42);
- Add_Goto (Table.States (356), 132, 43);
- Add_Goto (Table.States (356), 133, 44);
- Add_Goto (Table.States (356), 139, 47);
- Add_Goto (Table.States (356), 151, 50);
- Add_Goto (Table.States (356), 152, 51);
- Add_Goto (Table.States (356), 161, 53);
- Add_Goto (Table.States (356), 190, 57);
- Add_Goto (Table.States (356), 196, 59);
- Add_Goto (Table.States (356), 217, 68);
- Add_Goto (Table.States (356), 218, 526);
- Add_Goto (Table.States (356), 222, 70);
- Add_Goto (Table.States (356), 232, 72);
- Add_Goto (Table.States (356), 239, 73);
- Add_Goto (Table.States (356), 257, 83);
- Add_Goto (Table.States (356), 261, 86);
- Add_Goto (Table.States (356), 272, 92);
- Add_Goto (Table.States (356), 276, 93);
- Add_Goto (Table.States (356), 290, 96);
- Add_Goto (Table.States (356), 293, 97);
- Add_Goto (Table.States (356), 294, 98);
- Add_Goto (Table.States (356), 298, 99);
- Add_Goto (Table.States (356), 299, 361);
- Add_Goto (Table.States (356), 300, 390);
- Add_Goto (Table.States (356), 302, 100);
- Add_Goto (Table.States (356), 303, 101);
- Add_Goto (Table.States (356), 306, 363);
- Add_Goto (Table.States (356), 323, 114);
- Table.States (356).Kernel := To_Vector ((0 => (196, 21, 3,
False)));
- Table.States (356).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 218, 0)));
- Table.States (357).Action_List.Set_Capacity (5);
- Add_Action (Table.States (357), 76, 235);
- Add_Action (Table.States (357), 77, 527);
- Add_Action (Table.States (357), 84, 237);
- Add_Action (Table.States (357), 101, 239);
- Add_Action (Table.States (357), 102, 240);
- Table.States (357).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (357), 115, 241);
- Add_Goto (Table.States (357), 322, 242);
- Table.States (357).Kernel := To_Vector (((128, 239, 2, True),
(239, 239, 5, True), (239, 239, 2, True),
- (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (315, 239, 7, False)));
- Table.States (357).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 527)));
- Table.States (358).Action_List.Set_Capacity (3);
- Add_Action (Table.States (358), (22, 24, 43), (295, 4), 2,
select_alternative_4'Access, null);
- Table.States (358).Kernel := To_Vector ((0 => (295, 96, 0,
False)));
- Table.States (358).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 295, 2)));
- Table.States (359).Action_List.Set_Capacity (1);
- Add_Action (Table.States (359), 87, 528);
- Table.States (359).Kernel := To_Vector (((295, 192, 4, False),
(295, 192, 3, False), (295, 192, 3,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (303, 0), 3, simple_return_statement_0'Access, null);
+ Table.States (355).Kernel := To_Vector ((0 => (303, 97, 0,
False)));
+ Table.States (355).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 303, 3)));
+ Table.States (356).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (356), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (197, 1), 3, extended_return_statement_1'Access, null);
+ Table.States (356).Kernel := To_Vector ((0 => (197, 97, 0,
False)));
+ Table.States (356).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 197, 3)));
+ Table.States (357).Action_List.Set_Capacity (25);
+ Add_Action (Table.States (357), 4, 1);
+ Add_Action (Table.States (357), 5, 2);
+ Add_Action (Table.States (357), 13, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (357), 15, 3);
+ Add_Action (Table.States (357), 17, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (357), 18, 4);
+ Add_Action (Table.States (357), 24, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (357), 26, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (357), 27, 5);
+ Add_Action (Table.States (357), 28, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (357), 31, 9);
+ Add_Action (Table.States (357), 32, 10);
+ Add_Action (Table.States (357), 37, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (357), 41, 13);
+ Add_Action (Table.States (357), 48, 16);
+ Add_Action (Table.States (357), 52, 20);
+ Add_Action (Table.States (357), 57, 21);
+ Add_Action (Table.States (357), 58, 22);
+ Add_Action (Table.States (357), 61, 24);
+ Add_Action (Table.States (357), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (357), 79, 31);
+ Add_Action (Table.States (357), 94, 32);
+ Add_Action (Table.States (357), 105, 361);
+ Add_Action (Table.States (357), 106, 34);
+ Add_Action (Table.States (357), 107, 35);
+ Table.States (357).Goto_List.Set_Capacity (32);
+ Add_Goto (Table.States (357), 114, 37);
+ Add_Goto (Table.States (357), 124, 39);
+ Add_Goto (Table.States (357), 127, 40);
+ Add_Goto (Table.States (357), 129, 42);
+ Add_Goto (Table.States (357), 132, 43);
+ Add_Goto (Table.States (357), 133, 44);
+ Add_Goto (Table.States (357), 134, 45);
+ Add_Goto (Table.States (357), 140, 48);
+ Add_Goto (Table.States (357), 152, 51);
+ Add_Goto (Table.States (357), 153, 52);
+ Add_Goto (Table.States (357), 162, 54);
+ Add_Goto (Table.States (357), 191, 58);
+ Add_Goto (Table.States (357), 197, 60);
+ Add_Goto (Table.States (357), 218, 69);
+ Add_Goto (Table.States (357), 219, 530);
+ Add_Goto (Table.States (357), 223, 71);
+ Add_Goto (Table.States (357), 233, 73);
+ Add_Goto (Table.States (357), 240, 74);
+ Add_Goto (Table.States (357), 258, 84);
+ Add_Goto (Table.States (357), 262, 87);
+ Add_Goto (Table.States (357), 273, 93);
+ Add_Goto (Table.States (357), 277, 94);
+ Add_Goto (Table.States (357), 291, 97);
+ Add_Goto (Table.States (357), 294, 98);
+ Add_Goto (Table.States (357), 295, 99);
+ Add_Goto (Table.States (357), 299, 100);
+ Add_Goto (Table.States (357), 300, 362);
+ Add_Goto (Table.States (357), 301, 391);
+ Add_Goto (Table.States (357), 303, 101);
+ Add_Goto (Table.States (357), 304, 102);
+ Add_Goto (Table.States (357), 307, 364);
+ Add_Goto (Table.States (357), 324, 115);
+ Table.States (357).Kernel := To_Vector ((0 => (197, 21, 3,
False)));
+ Table.States (357).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 219, 0)));
+ Table.States (358).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (358), 76, 236);
+ Add_Action (Table.States (358), 77, 531);
+ Add_Action (Table.States (358), 85, 238);
+ Add_Action (Table.States (358), 102, 240);
+ Add_Action (Table.States (358), 103, 241);
+ Table.States (358).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (358), 116, 242);
+ Add_Goto (Table.States (358), 323, 243);
+ Table.States (358).Kernel := To_Vector (((129, 240, 2, True),
(240, 240, 5, True), (240, 240, 2, True),
+ (273, 240, 3, True), (294, 240, 2, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (316, 240, 7, False)));
+ Table.States (358).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 531)));
+ Table.States (359).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (359), (22, 24, 43), (296, 4), 2,
select_alternative_4'Access, null);
+ Table.States (359).Kernel := To_Vector ((0 => (296, 97, 0,
False)));
+ Table.States (359).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 296, 2)));
+ Table.States (360).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (360), 88, 532);
+ Table.States (360).Kernel := To_Vector (((296, 193, 4, False),
(296, 193, 3, False), (296, 193, 3,
False)));
- Table.States (359).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 87, 528)));
- Table.States (360).Action_List.Set_Capacity (7);
- Add_Action (Table.States (360), 76, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (360), 81, 529);
- Add_Action (Table.States (360), 82, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (360), 84, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (360), 96, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (360), 101, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (360), 102, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Table.States (360).Kernel := To_Vector (((131, 104, 1, False),
(239, 104, 0, False)));
- Table.States (360).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 239, 1)));
- Table.States (361).Action_List.Set_Capacity (29);
- Add_Action (Table.States (361), 4, 1);
- Add_Action (Table.States (361), 5, 2);
- Add_Action (Table.States (361), 13, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (361), 15, 3);
- Add_Action (Table.States (361), 17, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (361), 18, 4);
- Add_Action (Table.States (361), 22, Reduce, (300, 0), 1, null,
null);
- Add_Action (Table.States (361), 23, Reduce, (300, 0), 1, null,
null);
- Add_Action (Table.States (361), 24, Reduce, (300, 0), 1, null,
null);
- Add_Action (Table.States (361), 26, Reduce, (300, 0), 1, null,
null);
- Add_Action (Table.States (361), 27, 5);
- Add_Action (Table.States (361), 28, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (361), 31, 9);
- Add_Action (Table.States (361), 32, 10);
- Add_Action (Table.States (361), 37, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (361), 41, 13);
- Add_Action (Table.States (361), 43, Reduce, (300, 0), 1, null,
null);
- Add_Action (Table.States (361), 48, 16);
- Add_Action (Table.States (361), 52, 20);
- Add_Action (Table.States (361), 57, 21);
- Add_Action (Table.States (361), 58, 22);
- Add_Action (Table.States (361), 61, 24);
- Add_Action (Table.States (361), 68, Reduce, (300, 0), 1, null,
null);
- Add_Action (Table.States (361), 72, Reduce, (300, 0), 1, null,
null);
- Add_Action (Table.States (361), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (361), 93, 31);
- Add_Action (Table.States (361), 104, 360);
- Add_Action (Table.States (361), 105, 33);
- Add_Action (Table.States (361), 106, 34);
- Table.States (361).Goto_List.Set_Capacity (29);
- Add_Goto (Table.States (361), 113, 36);
- Add_Goto (Table.States (361), 123, 38);
- Add_Goto (Table.States (361), 126, 39);
- Add_Goto (Table.States (361), 128, 41);
- Add_Goto (Table.States (361), 131, 42);
- Add_Goto (Table.States (361), 132, 43);
- Add_Goto (Table.States (361), 133, 44);
- Add_Goto (Table.States (361), 139, 47);
- Add_Goto (Table.States (361), 151, 50);
- Add_Goto (Table.States (361), 152, 51);
- Add_Goto (Table.States (361), 161, 53);
- Add_Goto (Table.States (361), 190, 57);
- Add_Goto (Table.States (361), 196, 59);
- Add_Goto (Table.States (361), 217, 68);
- Add_Goto (Table.States (361), 222, 70);
- Add_Goto (Table.States (361), 232, 72);
- Add_Goto (Table.States (361), 239, 73);
- Add_Goto (Table.States (361), 257, 83);
- Add_Goto (Table.States (361), 261, 86);
- Add_Goto (Table.States (361), 272, 92);
- Add_Goto (Table.States (361), 276, 93);
- Add_Goto (Table.States (361), 290, 96);
- Add_Goto (Table.States (361), 293, 97);
- Add_Goto (Table.States (361), 294, 98);
- Add_Goto (Table.States (361), 298, 99);
- Add_Goto (Table.States (361), 302, 100);
- Add_Goto (Table.States (361), 303, 101);
- Add_Goto (Table.States (361), 306, 530);
- Add_Goto (Table.States (361), 323, 114);
- Table.States (361).Kernel := To_Vector (((299, 299, 2, True),
(300, 299, 0, False)));
- Table.States (361).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 300, 1)));
- Table.States (362).Action_List.Set_Capacity (3);
- Add_Action (Table.States (362), (22, 24, 43), (295, 3), 2, null,
null);
- Table.States (362).Kernel := To_Vector ((0 => (295, 300, 0,
False)));
- Table.States (362).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 295, 2)));
- Table.States (363).Action_List.Set_Capacity (29);
- Add_Action (Table.States (363), (4, 5, 13, 15, 17, 18, 22, 23, 24,
26, 27, 28, 31, 32, 37, 41, 43, 48, 52,
- 57, 58, 61, 68, 72, 73, 93, 104, 105, 106), (299, 1), 1, null,
null);
- Table.States (363).Kernel := To_Vector ((0 => (299, 306, 0,
False)));
- Table.States (363).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 299, 1)));
- Table.States (364).Action_List.Set_Capacity (4);
- Add_Action (Table.States (364), 22, Reduce, (160, 0), 2, null,
null);
- Add_Action (Table.States (364), 24, Reduce, (160, 0), 2, null,
null);
- Add_Action (Table.States (364), 43, Reduce, (160, 0), 2, null,
null);
- Add_Action (Table.States (364), 68, Reduce, (324, 2), 2, null,
null);
- Table.States (364).Kernel := To_Vector (((160, 300, 0, False),
(324, 300, 0, False)));
- Table.States (364).Minimal_Complete_Actions := To_Vector
(((Reduce, 160, 2), (Reduce, 324, 2)));
- Table.States (365).Action_List.Set_Capacity (23);
- Add_Action (Table.States (365), 4, 1);
- Add_Action (Table.States (365), 5, 2);
- Add_Action (Table.States (365), 13, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (365), 15, 3);
- Add_Action (Table.States (365), 17, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (365), 18, 4);
- Add_Action (Table.States (365), 24, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (365), 27, 5);
- Add_Action (Table.States (365), 28, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (365), 31, 9);
- Add_Action (Table.States (365), 32, 10);
- Add_Action (Table.States (365), 37, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (365), 41, 13);
- Add_Action (Table.States (365), 48, 16);
- Add_Action (Table.States (365), 52, 20);
- Add_Action (Table.States (365), 57, 21);
- Add_Action (Table.States (365), 58, 22);
- Add_Action (Table.States (365), 61, 24);
- Add_Action (Table.States (365), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (365), 93, 31);
- Add_Action (Table.States (365), 104, 360);
- Add_Action (Table.States (365), 105, 33);
- Add_Action (Table.States (365), 106, 34);
- Table.States (365).Goto_List.Set_Capacity (31);
- Add_Goto (Table.States (365), 113, 36);
- Add_Goto (Table.States (365), 123, 38);
- Add_Goto (Table.States (365), 126, 39);
- Add_Goto (Table.States (365), 128, 41);
- Add_Goto (Table.States (365), 131, 42);
- Add_Goto (Table.States (365), 132, 43);
- Add_Goto (Table.States (365), 133, 44);
- Add_Goto (Table.States (365), 139, 47);
- Add_Goto (Table.States (365), 151, 50);
- Add_Goto (Table.States (365), 152, 51);
- Add_Goto (Table.States (365), 161, 53);
- Add_Goto (Table.States (365), 190, 57);
- Add_Goto (Table.States (365), 196, 59);
- Add_Goto (Table.States (365), 217, 68);
- Add_Goto (Table.States (365), 222, 70);
- Add_Goto (Table.States (365), 232, 72);
- Add_Goto (Table.States (365), 239, 73);
- Add_Goto (Table.States (365), 257, 83);
- Add_Goto (Table.States (365), 261, 86);
- Add_Goto (Table.States (365), 272, 92);
- Add_Goto (Table.States (365), 276, 93);
- Add_Goto (Table.States (365), 290, 96);
- Add_Goto (Table.States (365), 293, 97);
- Add_Goto (Table.States (365), 294, 98);
- Add_Goto (Table.States (365), 298, 99);
- Add_Goto (Table.States (365), 299, 361);
- Add_Goto (Table.States (365), 300, 531);
- Add_Goto (Table.States (365), 302, 100);
- Add_Goto (Table.States (365), 303, 101);
- Add_Goto (Table.States (365), 306, 363);
- Add_Goto (Table.States (365), 323, 114);
- Table.States (365).Kernel := To_Vector ((0 => (152, 22, 3,
False)));
- Table.States (365).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 300, 0)));
- Table.States (366).Action_List.Set_Capacity (1);
+ Table.States (360).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 88, 532)));
+ Table.States (361).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (361), 76, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (361), 82, 533);
+ Add_Action (Table.States (361), 83, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (361), 85, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (361), 97, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (361), 102, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (361), 103, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Table.States (361).Kernel := To_Vector (((132, 105, 1, False),
(240, 105, 0, False)));
+ Table.States (361).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 240, 1)));
+ Table.States (362).Action_List.Set_Capacity (30);
+ Add_Action (Table.States (362), 4, 1);
+ Add_Action (Table.States (362), 5, 2);
+ Add_Action (Table.States (362), 13, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (362), 15, 3);
+ Add_Action (Table.States (362), 17, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (362), 18, 4);
+ Add_Action (Table.States (362), 22, Reduce, (301, 0), 1, null,
null);
+ Add_Action (Table.States (362), 23, Reduce, (301, 0), 1, null,
null);
+ Add_Action (Table.States (362), 24, Reduce, (301, 0), 1, null,
null);
+ Add_Action (Table.States (362), 26, Reduce, (301, 0), 1, null,
null);
+ Add_Action (Table.States (362), 27, 5);
+ Add_Action (Table.States (362), 28, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (362), 31, 9);
+ Add_Action (Table.States (362), 32, 10);
+ Add_Action (Table.States (362), 37, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (362), 41, 13);
+ Add_Action (Table.States (362), 43, Reduce, (301, 0), 1, null,
null);
+ Add_Action (Table.States (362), 48, 16);
+ Add_Action (Table.States (362), 52, 20);
+ Add_Action (Table.States (362), 57, 21);
+ Add_Action (Table.States (362), 58, 22);
+ Add_Action (Table.States (362), 61, 24);
+ Add_Action (Table.States (362), 68, Reduce, (301, 0), 1, null,
null);
+ Add_Action (Table.States (362), 72, Reduce, (301, 0), 1, null,
null);
+ Add_Action (Table.States (362), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (362), 79, 31);
+ Add_Action (Table.States (362), 94, 32);
+ Add_Action (Table.States (362), 105, 361);
+ Add_Action (Table.States (362), 106, 34);
+ Add_Action (Table.States (362), 107, 35);
+ Table.States (362).Goto_List.Set_Capacity (29);
+ Add_Goto (Table.States (362), 114, 37);
+ Add_Goto (Table.States (362), 124, 39);
+ Add_Goto (Table.States (362), 127, 40);
+ Add_Goto (Table.States (362), 129, 42);
+ Add_Goto (Table.States (362), 132, 43);
+ Add_Goto (Table.States (362), 133, 44);
+ Add_Goto (Table.States (362), 134, 45);
+ Add_Goto (Table.States (362), 140, 48);
+ Add_Goto (Table.States (362), 152, 51);
+ Add_Goto (Table.States (362), 153, 52);
+ Add_Goto (Table.States (362), 162, 54);
+ Add_Goto (Table.States (362), 191, 58);
+ Add_Goto (Table.States (362), 197, 60);
+ Add_Goto (Table.States (362), 218, 69);
+ Add_Goto (Table.States (362), 223, 71);
+ Add_Goto (Table.States (362), 233, 73);
+ Add_Goto (Table.States (362), 240, 74);
+ Add_Goto (Table.States (362), 258, 84);
+ Add_Goto (Table.States (362), 262, 87);
+ Add_Goto (Table.States (362), 273, 93);
+ Add_Goto (Table.States (362), 277, 94);
+ Add_Goto (Table.States (362), 291, 97);
+ Add_Goto (Table.States (362), 294, 98);
+ Add_Goto (Table.States (362), 295, 99);
+ Add_Goto (Table.States (362), 299, 100);
+ Add_Goto (Table.States (362), 303, 101);
+ Add_Goto (Table.States (362), 304, 102);
+ Add_Goto (Table.States (362), 307, 534);
+ Add_Goto (Table.States (362), 324, 115);
+ Table.States (362).Kernel := To_Vector (((300, 300, 2, True),
(301, 300, 0, False)));
+ Table.States (362).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 301, 1)));
+ Table.States (363).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (363), (22, 24, 43), (296, 3), 2, null,
null);
+ Table.States (363).Kernel := To_Vector ((0 => (296, 301, 0,
False)));
+ Table.States (363).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 296, 2)));
+ Table.States (364).Action_List.Set_Capacity (30);
+ Add_Action (Table.States (364), (4, 5, 13, 15, 17, 18, 22, 23, 24,
26, 27, 28, 31, 32, 37, 41, 43, 48, 52,
+ 57, 58, 61, 68, 72, 73, 79, 94, 105, 106, 107), (300, 1), 1, null,
null);
+ Table.States (364).Kernel := To_Vector ((0 => (300, 307, 0,
False)));
+ Table.States (364).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 300, 1)));
+ Table.States (365).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (365), 22, Reduce, (161, 0), 2, null,
null);
+ Add_Action (Table.States (365), 24, Reduce, (161, 0), 2, null,
null);
+ Add_Action (Table.States (365), 43, Reduce, (161, 0), 2, null,
null);
+ Add_Action (Table.States (365), 68, Reduce, (325, 2), 2, null,
null);
+ Table.States (365).Kernel := To_Vector (((161, 301, 0, False),
(325, 301, 0, False)));
+ Table.States (365).Minimal_Complete_Actions := To_Vector
(((Reduce, 161, 2), (Reduce, 325, 2)));
+ Table.States (366).Action_List.Set_Capacity (24);
+ Add_Action (Table.States (366), 4, 1);
+ Add_Action (Table.States (366), 5, 2);
+ Add_Action (Table.States (366), 13, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (366), 15, 3);
+ Add_Action (Table.States (366), 17, Reduce, (133, 1), 0, null,
null);
Add_Action (Table.States (366), 18, 4);
- Table.States (366).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (366), 160, 532);
- Add_Goto (Table.States (366), 161, 533);
- Table.States (366).Kernel := To_Vector ((0 => (323, 43, 5,
False)));
- Table.States (366).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 18, 4)));
- Table.States (367).Action_List.Set_Capacity (3);
- Add_Action (Table.States (367), 22, Reduce, (178, 1), 2, null,
null);
- Add_Action (Table.States (367), 43, Reduce, (178, 1), 2, null,
null);
- Add_Action (Table.States (367), 68, Reduce, (324, 1), 2, null,
null);
- Table.States (367).Kernel := To_Vector (((178, 300, 0, False),
(324, 300, 0, False)));
- Table.States (367).Minimal_Complete_Actions := To_Vector
(((Reduce, 178, 2), (Reduce, 324, 2)));
+ Add_Action (Table.States (366), 24, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (366), 27, 5);
+ Add_Action (Table.States (366), 28, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (366), 31, 9);
+ Add_Action (Table.States (366), 32, 10);
+ Add_Action (Table.States (366), 37, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (366), 41, 13);
+ Add_Action (Table.States (366), 48, 16);
+ Add_Action (Table.States (366), 52, 20);
+ Add_Action (Table.States (366), 57, 21);
+ Add_Action (Table.States (366), 58, 22);
+ Add_Action (Table.States (366), 61, 24);
+ Add_Action (Table.States (366), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (366), 79, 31);
+ Add_Action (Table.States (366), 94, 32);
+ Add_Action (Table.States (366), 105, 361);
+ Add_Action (Table.States (366), 106, 34);
+ Add_Action (Table.States (366), 107, 35);
+ Table.States (366).Goto_List.Set_Capacity (31);
+ Add_Goto (Table.States (366), 114, 37);
+ Add_Goto (Table.States (366), 124, 39);
+ Add_Goto (Table.States (366), 127, 40);
+ Add_Goto (Table.States (366), 129, 42);
+ Add_Goto (Table.States (366), 132, 43);
+ Add_Goto (Table.States (366), 133, 44);
+ Add_Goto (Table.States (366), 134, 45);
+ Add_Goto (Table.States (366), 140, 48);
+ Add_Goto (Table.States (366), 152, 51);
+ Add_Goto (Table.States (366), 153, 52);
+ Add_Goto (Table.States (366), 162, 54);
+ Add_Goto (Table.States (366), 191, 58);
+ Add_Goto (Table.States (366), 197, 60);
+ Add_Goto (Table.States (366), 218, 69);
+ Add_Goto (Table.States (366), 223, 71);
+ Add_Goto (Table.States (366), 233, 73);
+ Add_Goto (Table.States (366), 240, 74);
+ Add_Goto (Table.States (366), 258, 84);
+ Add_Goto (Table.States (366), 262, 87);
+ Add_Goto (Table.States (366), 273, 93);
+ Add_Goto (Table.States (366), 277, 94);
+ Add_Goto (Table.States (366), 291, 97);
+ Add_Goto (Table.States (366), 294, 98);
+ Add_Goto (Table.States (366), 295, 99);
+ Add_Goto (Table.States (366), 299, 100);
+ Add_Goto (Table.States (366), 300, 362);
+ Add_Goto (Table.States (366), 301, 535);
+ Add_Goto (Table.States (366), 303, 101);
+ Add_Goto (Table.States (366), 304, 102);
+ Add_Goto (Table.States (366), 307, 364);
+ Add_Goto (Table.States (366), 324, 115);
+ Table.States (366).Kernel := To_Vector ((0 => (153, 22, 3,
False)));
+ Table.States (366).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 301, 0)));
+ Table.States (367).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (367), 18, 4);
+ Table.States (367).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (367), 161, 536);
+ Add_Goto (Table.States (367), 162, 537);
+ Table.States (367).Kernel := To_Vector ((0 => (324, 43, 5,
False)));
+ Table.States (367).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 18, 4)));
Table.States (368).Action_List.Set_Capacity (3);
- Add_Action (Table.States (368), 22, Reduce, (178, 0), 2, null,
null);
- Add_Action (Table.States (368), 43, Reduce, (178, 0), 2, null,
null);
- Add_Action (Table.States (368), 68, Reduce, (324, 0), 2, null,
null);
- Table.States (368).Kernel := To_Vector (((178, 300, 0, False),
(324, 300, 0, False)));
- Table.States (368).Minimal_Complete_Actions := To_Vector
(((Reduce, 178, 2), (Reduce, 324, 2)));
- Table.States (369).Action_List.Set_Capacity (4);
- Add_Action (Table.States (369), 4, 1);
- Add_Action (Table.States (369), 18, 4);
- Add_Action (Table.States (369), 67, 199);
- Add_Action (Table.States (369), 72, 200);
- Table.States (369).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (369), 113, 201);
- Add_Goto (Table.States (369), 160, 202);
- Add_Goto (Table.States (369), 161, 533);
- Add_Goto (Table.States (369), 295, 534);
- Table.States (369).Kernel := To_Vector ((0 => (296, 43, 2, True)));
- Table.States (369).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 67, 199)));
- Table.States (369).Minimal_Complete_Actions_Recursive := True;
- Table.States (370).Action_List.Set_Capacity (23);
+ Add_Action (Table.States (368), 22, Reduce, (179, 1), 2, null,
null);
+ Add_Action (Table.States (368), 43, Reduce, (179, 1), 2, null,
null);
+ Add_Action (Table.States (368), 68, Reduce, (325, 1), 2, null,
null);
+ Table.States (368).Kernel := To_Vector (((179, 301, 0, False),
(325, 301, 0, False)));
+ Table.States (368).Minimal_Complete_Actions := To_Vector
(((Reduce, 179, 2), (Reduce, 325, 2)));
+ Table.States (369).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (369), 22, Reduce, (179, 0), 2, null,
null);
+ Add_Action (Table.States (369), 43, Reduce, (179, 0), 2, null,
null);
+ Add_Action (Table.States (369), 68, Reduce, (325, 0), 2, null,
null);
+ Table.States (369).Kernel := To_Vector (((179, 301, 0, False),
(325, 301, 0, False)));
+ Table.States (369).Minimal_Complete_Actions := To_Vector
(((Reduce, 179, 2), (Reduce, 325, 2)));
+ Table.States (370).Action_List.Set_Capacity (4);
Add_Action (Table.States (370), 4, 1);
- Add_Action (Table.States (370), 5, 2);
- Add_Action (Table.States (370), 13, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (370), 15, 3);
- Add_Action (Table.States (370), 17, Reduce, (132, 1), 0, null,
null);
Add_Action (Table.States (370), 18, 4);
- Add_Action (Table.States (370), 24, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (370), 27, 5);
- Add_Action (Table.States (370), 28, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (370), 31, 9);
- Add_Action (Table.States (370), 32, 10);
- Add_Action (Table.States (370), 37, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (370), 41, 13);
- Add_Action (Table.States (370), 48, 16);
- Add_Action (Table.States (370), 52, 20);
- Add_Action (Table.States (370), 57, 21);
- Add_Action (Table.States (370), 58, 22);
- Add_Action (Table.States (370), 61, 24);
- Add_Action (Table.States (370), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (370), 93, 31);
- Add_Action (Table.States (370), 104, 360);
- Add_Action (Table.States (370), 105, 33);
- Add_Action (Table.States (370), 106, 34);
- Table.States (370).Goto_List.Set_Capacity (31);
- Add_Goto (Table.States (370), 113, 36);
- Add_Goto (Table.States (370), 123, 38);
- Add_Goto (Table.States (370), 126, 39);
- Add_Goto (Table.States (370), 128, 41);
- Add_Goto (Table.States (370), 131, 42);
- Add_Goto (Table.States (370), 132, 43);
- Add_Goto (Table.States (370), 133, 44);
- Add_Goto (Table.States (370), 139, 47);
- Add_Goto (Table.States (370), 151, 50);
- Add_Goto (Table.States (370), 152, 51);
- Add_Goto (Table.States (370), 161, 53);
- Add_Goto (Table.States (370), 190, 57);
- Add_Goto (Table.States (370), 196, 59);
- Add_Goto (Table.States (370), 217, 68);
- Add_Goto (Table.States (370), 222, 70);
- Add_Goto (Table.States (370), 232, 72);
- Add_Goto (Table.States (370), 239, 73);
- Add_Goto (Table.States (370), 257, 83);
- Add_Goto (Table.States (370), 261, 86);
- Add_Goto (Table.States (370), 272, 92);
- Add_Goto (Table.States (370), 276, 93);
- Add_Goto (Table.States (370), 290, 96);
- Add_Goto (Table.States (370), 293, 97);
- Add_Goto (Table.States (370), 294, 98);
- Add_Goto (Table.States (370), 298, 99);
- Add_Goto (Table.States (370), 299, 361);
- Add_Goto (Table.States (370), 300, 535);
- Add_Goto (Table.States (370), 302, 100);
- Add_Goto (Table.States (370), 303, 101);
- Add_Goto (Table.States (370), 306, 363);
- Add_Goto (Table.States (370), 323, 114);
- Table.States (370).Kernel := To_Vector ((0 => (294, 22, 3,
False)));
- Table.States (370).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 300, 0)));
- Table.States (371).Action_List.Set_Capacity (1);
- Add_Action (Table.States (371), 61, 536);
- Table.States (371).Kernel := To_Vector ((0 => (294, 24, 2,
False)));
- Table.States (371).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 61, 536)));
+ Add_Action (Table.States (370), 67, 200);
+ Add_Action (Table.States (370), 72, 201);
+ Table.States (370).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (370), 114, 202);
+ Add_Goto (Table.States (370), 161, 203);
+ Add_Goto (Table.States (370), 162, 537);
+ Add_Goto (Table.States (370), 296, 538);
+ Table.States (370).Kernel := To_Vector ((0 => (297, 43, 2, True)));
+ Table.States (370).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 67, 200)));
+ Table.States (370).Minimal_Complete_Actions_Recursive := True;
+ Table.States (371).Action_List.Set_Capacity (24);
+ Add_Action (Table.States (371), 4, 1);
+ Add_Action (Table.States (371), 5, 2);
+ Add_Action (Table.States (371), 13, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (371), 15, 3);
+ Add_Action (Table.States (371), 17, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (371), 18, 4);
+ Add_Action (Table.States (371), 24, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (371), 27, 5);
+ Add_Action (Table.States (371), 28, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (371), 31, 9);
+ Add_Action (Table.States (371), 32, 10);
+ Add_Action (Table.States (371), 37, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (371), 41, 13);
+ Add_Action (Table.States (371), 48, 16);
+ Add_Action (Table.States (371), 52, 20);
+ Add_Action (Table.States (371), 57, 21);
+ Add_Action (Table.States (371), 58, 22);
+ Add_Action (Table.States (371), 61, 24);
+ Add_Action (Table.States (371), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (371), 79, 31);
+ Add_Action (Table.States (371), 94, 32);
+ Add_Action (Table.States (371), 105, 361);
+ Add_Action (Table.States (371), 106, 34);
+ Add_Action (Table.States (371), 107, 35);
+ Table.States (371).Goto_List.Set_Capacity (31);
+ Add_Goto (Table.States (371), 114, 37);
+ Add_Goto (Table.States (371), 124, 39);
+ Add_Goto (Table.States (371), 127, 40);
+ Add_Goto (Table.States (371), 129, 42);
+ Add_Goto (Table.States (371), 132, 43);
+ Add_Goto (Table.States (371), 133, 44);
+ Add_Goto (Table.States (371), 134, 45);
+ Add_Goto (Table.States (371), 140, 48);
+ Add_Goto (Table.States (371), 152, 51);
+ Add_Goto (Table.States (371), 153, 52);
+ Add_Goto (Table.States (371), 162, 54);
+ Add_Goto (Table.States (371), 191, 58);
+ Add_Goto (Table.States (371), 197, 60);
+ Add_Goto (Table.States (371), 218, 69);
+ Add_Goto (Table.States (371), 223, 71);
+ Add_Goto (Table.States (371), 233, 73);
+ Add_Goto (Table.States (371), 240, 74);
+ Add_Goto (Table.States (371), 258, 84);
+ Add_Goto (Table.States (371), 262, 87);
+ Add_Goto (Table.States (371), 273, 93);
+ Add_Goto (Table.States (371), 277, 94);
+ Add_Goto (Table.States (371), 291, 97);
+ Add_Goto (Table.States (371), 294, 98);
+ Add_Goto (Table.States (371), 295, 99);
+ Add_Goto (Table.States (371), 299, 100);
+ Add_Goto (Table.States (371), 300, 362);
+ Add_Goto (Table.States (371), 301, 539);
+ Add_Goto (Table.States (371), 303, 101);
+ Add_Goto (Table.States (371), 304, 102);
+ Add_Goto (Table.States (371), 307, 364);
+ Add_Goto (Table.States (371), 324, 115);
+ Table.States (371).Kernel := To_Vector ((0 => (295, 22, 3,
False)));
+ Table.States (371).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 301, 0)));
Table.States (372).Action_List.Set_Capacity (1);
- Add_Action (Table.States (372), 5, 537);
- Table.States (372).Kernel := To_Vector ((0 => (126, 68, 4,
False)));
- Table.States (372).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 5, 537)));
- Table.States (373).Action_List.Set_Capacity (4);
- Add_Action (Table.States (373), 40, 483);
- Add_Action (Table.States (373), 104, 119);
- Add_Action (Table.States (373), 105, 33);
- Add_Action (Table.States (373), 106, 34);
- Table.States (373).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (373), 128, 41);
- Add_Goto (Table.States (373), 239, 484);
- Add_Goto (Table.States (373), 272, 92);
- Add_Goto (Table.States (373), 293, 97);
- Add_Goto (Table.States (373), 314, 538);
- Table.States (373).Kernel := To_Vector ((0 => (313, 35, 2,
False)));
- Table.States (373).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (374).Action_List.Set_Capacity (2);
- Add_Action (Table.States (374), 35, 539);
- Add_Conflict (Table.States (374), 35, (122, 1), 0, null, null);
- Add_Action (Table.States (374), 74, 337);
- Table.States (374).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (374), 122, 540);
- Table.States (374).Kernel := To_Vector (((316, 104, 4, False),
(317, 104, 3, False)));
- Table.States (374).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 539)));
- Table.States (375).Action_List.Set_Capacity (4);
- Add_Action (Table.States (375), 35, Reduce, (169, 2), 0, null,
null);
- Add_Action (Table.States (375), 74, Reduce, (169, 2), 0, null,
null);
- Add_Action (Table.States (375), 76, 377);
- Add_Action (Table.States (375), 96, Reduce, (169, 2), 0, null,
null);
+ Add_Action (Table.States (372), 61, 540);
+ Table.States (372).Kernel := To_Vector ((0 => (295, 24, 2,
False)));
+ Table.States (372).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 61, 540)));
+ Table.States (373).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (373), 5, 541);
+ Table.States (373).Kernel := To_Vector ((0 => (127, 68, 4,
False)));
+ Table.States (373).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 5, 541)));
+ Table.States (374).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (374), 40, 486);
+ Add_Action (Table.States (374), 79, 31);
+ Add_Action (Table.States (374), 105, 120);
+ Add_Action (Table.States (374), 106, 34);
+ Add_Action (Table.States (374), 107, 35);
+ Table.States (374).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (374), 129, 42);
+ Add_Goto (Table.States (374), 240, 487);
+ Add_Goto (Table.States (374), 273, 93);
+ Add_Goto (Table.States (374), 294, 98);
+ Add_Goto (Table.States (374), 315, 542);
+ Table.States (374).Kernel := To_Vector ((0 => (314, 35, 2,
False)));
+ Table.States (374).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (375).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (375), 35, 543);
+ Add_Conflict (Table.States (375), 35, (123, 1), 0, null, null);
+ Add_Action (Table.States (375), 74, 338);
Table.States (375).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (375), 169, 541);
- Table.States (375).Kernel := To_Vector (((319, 104, 6, False),
(319, 104, 3, False), (319, 104, 1,
+ Add_Goto (Table.States (375), 123, 544);
+ Table.States (375).Kernel := To_Vector (((317, 105, 4, False),
(318, 105, 3, False)));
+ Table.States (375).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 543)));
+ end Subr_7;
+ procedure Subr_8
+ is begin
+ Table.States (376).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (376), 35, Reduce, (170, 2), 0, null,
null);
+ Add_Action (Table.States (376), 74, Reduce, (170, 2), 0, null,
null);
+ Add_Action (Table.States (376), 76, 378);
+ Add_Action (Table.States (376), 97, Reduce, (170, 2), 0, null,
null);
+ Table.States (376).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (376), 170, 545);
+ Table.States (376).Kernel := To_Vector (((320, 105, 6, False),
(320, 105, 3, False), (320, 105, 1,
False)));
- Table.States (375).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 169, 0)));
- Table.States (376).Action_List.Set_Capacity (2);
- Add_Action (Table.States (376), 35, 542);
- Add_Action (Table.States (376), 96, 543);
- Table.States (376).Kernel := To_Vector (((305, 122, 6, False),
(305, 122, 3, False), (305, 122, 1,
+ Table.States (376).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 170, 0)));
+ Table.States (377).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (377), 35, 546);
+ Add_Action (Table.States (377), 97, 547);
+ Table.States (377).Kernel := To_Vector (((306, 123, 6, False),
(306, 123, 3, False), (306, 123, 1,
False)));
- Table.States (376).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 543)));
- Table.States (377).Action_List.Set_Capacity (4);
- Add_Action (Table.States (377), 77, Reduce, (170, 4), 0, null,
null);
- Add_Action (Table.States (377), 80, 544);
- Add_Action (Table.States (377), 96, Reduce, (170, 4), 0, null,
null);
- Add_Action (Table.States (377), 104, 164);
- Table.States (377).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (377), 170, 545);
- Add_Goto (Table.States (377), 171, 546);
- Add_Goto (Table.States (377), 219, 547);
- Table.States (377).Kernel := To_Vector (((169, 76, 2, False),
(169, 76, 1, False)));
- Table.States (377).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 171, 0)));
- Table.States (378).Action_List.Set_Capacity (2);
- Add_Action (Table.States (378), 35, 548);
- Add_Action (Table.States (378), 96, 549);
- Table.States (378).Kernel := To_Vector (((206, 169, 3, False),
(223, 169, 3, False), (223, 169, 1, False),
- (259, 169, 6, False), (260, 169, 3, False)));
- Table.States (378).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 549)));
- Table.States (379).Action_List.Set_Capacity (3);
- Add_Action (Table.States (379), 104, 119);
- Add_Action (Table.States (379), 105, 33);
- Add_Action (Table.States (379), 106, 34);
- Table.States (379).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (379), 128, 41);
- Add_Goto (Table.States (379), 238, 550);
- Add_Goto (Table.States (379), 239, 219);
- Add_Goto (Table.States (379), 272, 92);
- Add_Goto (Table.States (379), 293, 97);
- Table.States (379).Kernel := To_Vector ((0 => (331, 69, 2,
False)));
- Table.States (379).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (380).Action_List.Set_Capacity (2);
- Add_Action (Table.States (380), 83, 381);
- Add_Action (Table.States (380), 96, 551);
- Table.States (380).Kernel := To_Vector (((238, 238, 2, True),
(331, 238, 1, False)));
- Table.States (380).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 551)));
- Table.States (381).Action_List.Set_Capacity (3);
- Add_Action (Table.States (381), 104, 119);
- Add_Action (Table.States (381), 105, 33);
- Add_Action (Table.States (381), 106, 34);
- Table.States (381).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (381), 128, 41);
- Add_Goto (Table.States (381), 239, 552);
- Add_Goto (Table.States (381), 272, 92);
- Add_Goto (Table.States (381), 293, 97);
- Table.States (381).Kernel := To_Vector ((0 => (238, 83, 1, True)));
- Table.States (381).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (381).Minimal_Complete_Actions_Recursive := True;
- Table.States (382).Action_List.Set_Capacity (40);
- Add_Action (Table.States (382), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (331, 2), 3,
+ Table.States (377).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 547)));
+ Table.States (378).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (378), 77, Reduce, (171, 4), 0, null,
null);
+ Add_Action (Table.States (378), 81, 548);
+ Add_Action (Table.States (378), 97, Reduce, (171, 4), 0, null,
null);
+ Add_Action (Table.States (378), 105, 165);
+ Table.States (378).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (378), 171, 549);
+ Add_Goto (Table.States (378), 172, 550);
+ Add_Goto (Table.States (378), 220, 551);
+ Table.States (378).Kernel := To_Vector (((170, 76, 2, False),
(170, 76, 1, False)));
+ Table.States (378).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 172, 0)));
+ Table.States (379).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (379), 35, 552);
+ Add_Action (Table.States (379), 97, 553);
+ Table.States (379).Kernel := To_Vector (((207, 170, 3, False),
(224, 170, 3, False), (224, 170, 1, False),
+ (260, 170, 6, False), (261, 170, 3, False)));
+ Table.States (379).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 553)));
+ Table.States (380).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (380), 79, 31);
+ Add_Action (Table.States (380), 105, 120);
+ Add_Action (Table.States (380), 106, 34);
+ Add_Action (Table.States (380), 107, 35);
+ Table.States (380).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (380), 129, 42);
+ Add_Goto (Table.States (380), 239, 554);
+ Add_Goto (Table.States (380), 240, 220);
+ Add_Goto (Table.States (380), 273, 93);
+ Add_Goto (Table.States (380), 294, 98);
+ Table.States (380).Kernel := To_Vector ((0 => (332, 69, 2,
False)));
+ Table.States (380).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (381).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (381), 84, 382);
+ Add_Action (Table.States (381), 97, 555);
+ Table.States (381).Kernel := To_Vector (((239, 239, 2, True),
(332, 239, 1, False)));
+ Table.States (381).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 555)));
+ Table.States (382).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (382), 79, 31);
+ Add_Action (Table.States (382), 105, 120);
+ Add_Action (Table.States (382), 106, 34);
+ Add_Action (Table.States (382), 107, 35);
+ Table.States (382).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (382), 129, 42);
+ Add_Goto (Table.States (382), 240, 556);
+ Add_Goto (Table.States (382), 273, 93);
+ Add_Goto (Table.States (382), 294, 98);
+ Table.States (382).Kernel := To_Vector ((0 => (239, 84, 1, True)));
+ Table.States (382).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (382).Minimal_Complete_Actions_Recursive := True;
+ Table.States (383).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (383), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (332, 2), 3,
use_clause_2'Access, null);
- Table.States (382).Kernel := To_Vector ((0 => (331, 96, 0,
False)));
- Table.States (382).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 331, 3)));
- Table.States (383).Action_List.Set_Capacity (39);
- Add_Action (Table.States (383), (4, 5, 13, 15, 17, 18, 25, 27, 28,
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
- 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93,
104, 105, 106, 107), (332, 3), 3,
- with_clause_3'Access, null);
- Table.States (383).Kernel := To_Vector ((0 => (332, 96, 0,
False)));
+ Table.States (383).Kernel := To_Vector ((0 => (332, 97, 0,
False)));
Table.States (383).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 332, 3)));
- Table.States (384).Action_List.Set_Capacity (46);
- Add_Action (Table.States (384), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (217, 0), 3, goto_label_0'Access, null);
- Table.States (384).Kernel := To_Vector ((0 => (217, 90, 0,
False)));
- Table.States (384).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 217, 3)));
- Table.States (385).Action_List.Set_Capacity (1);
- Add_Action (Table.States (385), 56, 553);
- Table.States (385).Kernel := To_Vector ((0 => (245, 26, 3,
False)));
- Table.States (385).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 56, 553)));
+ Table.States (384).Action_List.Set_Capacity (40);
+ Add_Action (Table.States (384), (4, 5, 13, 15, 17, 18, 25, 27, 28,
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
+ 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 79,
94, 105, 106, 107, 108), (333, 3), 3,
+ with_clause_3'Access, null);
+ Table.States (384).Kernel := To_Vector ((0 => (333, 97, 0,
False)));
+ Table.States (384).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 333, 3)));
+ Table.States (385).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (385), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (218, 0), 3, goto_label_0'Access, null);
+ Table.States (385).Kernel := To_Vector ((0 => (218, 91, 0,
False)));
+ Table.States (385).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 218, 3)));
Table.States (386).Action_List.Set_Capacity (1);
- Add_Action (Table.States (386), 41, 554);
- Table.States (386).Kernel := To_Vector ((0 => (241, 40, 1,
False)));
- Table.States (386).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 41, 554)));
+ Add_Action (Table.States (386), 56, 557);
+ Table.States (386).Kernel := To_Vector ((0 => (246, 26, 3,
False)));
+ Table.States (386).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 56, 557)));
Table.States (387).Action_List.Set_Capacity (1);
- Add_Action (Table.States (387), 56, 555);
- Table.States (387).Kernel := To_Vector ((0 => (245, 114, 3,
False)));
- Table.States (387).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 56, 555)));
- Table.States (388).Action_List.Set_Capacity (4);
- Add_Action (Table.States (388), 7, 556);
- Add_Action (Table.States (388), 104, 119);
- Add_Action (Table.States (388), 105, 33);
- Add_Action (Table.States (388), 106, 34);
- Table.States (388).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (388), 128, 41);
- Add_Goto (Table.States (388), 239, 557);
- Add_Goto (Table.States (388), 272, 92);
- Add_Goto (Table.States (388), 293, 97);
- Table.States (388).Kernel := To_Vector (((114, 241, 2, False),
(114, 241, 3, True), (114, 241, 2, False),
- (245, 241, 4, False)));
- Table.States (388).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 7, 556)));
- Table.States (389).Action_List.Set_Capacity (1);
- Add_Action (Table.States (389), 24, 558);
- Table.States (389).Kernel := To_Vector ((0 => (133, 218, 2,
False)));
- Table.States (389).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 558)));
- Table.States (390).Action_List.Set_Capacity (2);
- Add_Action (Table.States (390), 24, Reduce, (218, 1), 1, null,
null);
- Add_Action (Table.States (390), 26, 559);
- Table.States (390).Kernel := To_Vector (((218, 300, 1, False),
(218, 300, 0, False)));
- Table.States (390).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 218, 1)));
- Table.States (391).Action_List.Set_Capacity (18);
- Add_Action (Table.States (391), (13, 24, 25, 28, 29, 30, 40, 46,
47, 48, 49, 50, 51, 63, 66, 69, 71, 104),
- (158, 2), 1, null, null);
- Table.States (391).Kernel := To_Vector ((0 => (158, 157, 0,
False)));
- Table.States (391).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 158, 1)));
+ Add_Action (Table.States (387), 41, 558);
+ Table.States (387).Kernel := To_Vector ((0 => (242, 40, 1,
False)));
+ Table.States (387).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 41, 558)));
+ Table.States (388).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (388), 56, 559);
+ Table.States (388).Kernel := To_Vector ((0 => (246, 115, 3,
False)));
+ Table.States (388).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 56, 559)));
+ Table.States (389).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (389), 7, 560);
+ Add_Action (Table.States (389), 79, 31);
+ Add_Action (Table.States (389), 105, 120);
+ Add_Action (Table.States (389), 106, 34);
+ Add_Action (Table.States (389), 107, 35);
+ Table.States (389).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (389), 129, 42);
+ Add_Goto (Table.States (389), 240, 561);
+ Add_Goto (Table.States (389), 273, 93);
+ Add_Goto (Table.States (389), 294, 98);
+ Table.States (389).Kernel := To_Vector (((115, 242, 2, False),
(115, 242, 3, True), (115, 242, 2, False),
+ (246, 242, 4, False)));
+ Table.States (389).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 7, 560)));
+ Table.States (390).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (390), 24, 562);
+ Table.States (390).Kernel := To_Vector ((0 => (134, 219, 2,
False)));
+ Table.States (390).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 562)));
+ Table.States (391).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (391), 24, Reduce, (219, 1), 1, null,
null);
+ Add_Action (Table.States (391), 26, 563);
+ Table.States (391).Kernel := To_Vector (((219, 301, 1, False),
(219, 301, 0, False)));
+ Table.States (391).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 219, 1)));
Table.States (392).Action_List.Set_Capacity (18);
- Add_Action (Table.States (392), 13, Reduce, (159, 0), 1, null,
null);
- Add_Action (Table.States (392), 24, Reduce, (159, 0), 1, null,
null);
- Add_Action (Table.States (392), 25, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (392), 28, 183);
- Add_Action (Table.States (392), 29, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (392), 30, 8);
- Add_Action (Table.States (392), 40, 12);
- Add_Action (Table.States (392), 46, 14);
- Add_Action (Table.States (392), 47, 15);
- Add_Action (Table.States (392), 48, 16);
- Add_Action (Table.States (392), 49, Reduce, (159, 0), 1, null,
null);
- Add_Action (Table.States (392), 50, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (392), 51, 19);
- Add_Action (Table.States (392), 63, 25);
- Add_Action (Table.States (392), 66, 26);
- Add_Action (Table.States (392), 69, 27);
- Add_Action (Table.States (392), 71, 28);
- Add_Action (Table.States (392), 104, 185);
- Table.States (392).Goto_List.Set_Capacity (51);
- Add_Goto (Table.States (392), 112, 35);
- Add_Goto (Table.States (392), 121, 37);
- Add_Goto (Table.States (392), 127, 40);
- Add_Goto (Table.States (392), 134, 45);
- Add_Goto (Table.States (392), 135, 46);
- Add_Goto (Table.States (392), 157, 560);
- Add_Goto (Table.States (392), 179, 54);
- Add_Goto (Table.States (392), 182, 55);
- Add_Goto (Table.States (392), 186, 56);
- Add_Goto (Table.States (392), 193, 58);
- Add_Goto (Table.States (392), 206, 60);
- Add_Goto (Table.States (392), 207, 61);
- Add_Goto (Table.States (392), 209, 62);
- Add_Goto (Table.States (392), 210, 63);
- Add_Goto (Table.States (392), 213, 64);
- Add_Goto (Table.States (392), 214, 65);
- Add_Goto (Table.States (392), 215, 66);
- Add_Goto (Table.States (392), 216, 67);
- Add_Goto (Table.States (392), 219, 69);
- Add_Goto (Table.States (392), 223, 71);
- Add_Goto (Table.States (392), 243, 74);
- Add_Goto (Table.States (392), 244, 75);
- Add_Goto (Table.States (392), 245, 76);
- Add_Goto (Table.States (392), 246, 77);
- Add_Goto (Table.States (392), 247, 78);
- Add_Goto (Table.States (392), 248, 79);
- Add_Goto (Table.States (392), 249, 80);
- Add_Goto (Table.States (392), 250, 81);
- Add_Goto (Table.States (392), 251, 82);
- Add_Goto (Table.States (392), 257, 561);
- Add_Goto (Table.States (392), 259, 84);
- Add_Goto (Table.States (392), 260, 85);
- Add_Goto (Table.States (392), 262, 87);
- Add_Goto (Table.States (392), 263, 88);
- Add_Goto (Table.States (392), 264, 89);
- Add_Goto (Table.States (392), 265, 90);
- Add_Goto (Table.States (392), 271, 91);
- Add_Goto (Table.States (392), 281, 94);
- Add_Goto (Table.States (392), 289, 95);
- Add_Goto (Table.States (392), 304, 102);
- Add_Goto (Table.States (392), 305, 103);
- Add_Goto (Table.States (392), 307, 105);
- Add_Goto (Table.States (392), 308, 106);
- Add_Goto (Table.States (392), 309, 107);
- Add_Goto (Table.States (392), 311, 108);
- Add_Goto (Table.States (392), 313, 109);
- Add_Goto (Table.States (392), 316, 111);
- Add_Goto (Table.States (392), 317, 112);
- Add_Goto (Table.States (392), 319, 113);
- Add_Goto (Table.States (392), 325, 115);
- Add_Goto (Table.States (392), 331, 116);
- Table.States (392).Kernel := To_Vector (((158, 158, 3, True),
(158, 158, 3, True), (159, 158, 0, False)));
+ Add_Action (Table.States (392), (13, 24, 25, 28, 29, 30, 40, 46,
47, 48, 49, 50, 51, 63, 66, 69, 71, 105),
+ (159, 2), 1, null, null);
+ Table.States (392).Kernel := To_Vector ((0 => (159, 158, 0,
False)));
Table.States (392).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 159, 1)));
- end Subr_7;
- procedure Subr_8
- is begin
- Table.States (393).Action_List.Set_Capacity (1);
- Add_Action (Table.States (393), 13, 562);
- Table.States (393).Kernel := To_Vector ((0 => (133, 159, 3,
False)));
- Table.States (393).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 13, 562)));
- Table.States (394).Action_List.Set_Capacity (18);
- Add_Action (Table.States (394), (13, 24, 25, 28, 29, 30, 40, 46,
47, 48, 49, 50, 51, 63, 66, 69, 71, 104),
- (158, 3), 1, null, null);
- Table.States (394).Kernel := To_Vector ((0 => (158, 257, 0,
False)));
- Table.States (394).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 158, 1)));
- Table.States (395).Action_List.Set_Capacity (3);
- Add_Action (Table.States (395), 33, 311);
- Add_Action (Table.States (395), 42, 312);
- Add_Action (Table.States (395), 81, 313);
- Table.States (395).Kernel := To_Vector (((230, 104, 5, False),
(230, 104, 4, False), (230, 104, 3, False),
- (230, 104, 3, False), (230, 104, 2, False), (230, 104, 2, False)));
- Table.States (395).Minimal_Complete_Actions := To_Vector (((Shift,
42, 312), (Shift, 33, 311)));
- Table.States (396).Action_List.Set_Capacity (1);
- Add_Action (Table.States (396), 24, 563);
- Table.States (396).Kernel := To_Vector ((0 => (232, 300, 3,
False)));
- Table.States (396).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 563)));
- Table.States (397).Action_List.Set_Capacity (23);
- Add_Action (Table.States (397), 4, 1);
- Add_Action (Table.States (397), 5, 2);
- Add_Action (Table.States (397), 13, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (397), 15, 3);
- Add_Action (Table.States (397), 17, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (397), 18, 4);
- Add_Action (Table.States (397), 24, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (397), 27, 5);
- Add_Action (Table.States (397), 28, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (397), 31, 9);
- Add_Action (Table.States (397), 32, 10);
- Add_Action (Table.States (397), 37, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (397), 41, 13);
- Add_Action (Table.States (397), 48, 16);
- Add_Action (Table.States (397), 52, 20);
- Add_Action (Table.States (397), 57, 21);
- Add_Action (Table.States (397), 58, 22);
- Add_Action (Table.States (397), 61, 24);
- Add_Action (Table.States (397), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (397), 93, 31);
- Add_Action (Table.States (397), 104, 360);
- Add_Action (Table.States (397), 105, 33);
- Add_Action (Table.States (397), 106, 34);
- Table.States (397).Goto_List.Set_Capacity (31);
- Add_Goto (Table.States (397), 113, 36);
- Add_Goto (Table.States (397), 123, 38);
- Add_Goto (Table.States (397), 126, 39);
- Add_Goto (Table.States (397), 128, 41);
- Add_Goto (Table.States (397), 131, 42);
- Add_Goto (Table.States (397), 132, 43);
- Add_Goto (Table.States (397), 133, 44);
- Add_Goto (Table.States (397), 139, 47);
- Add_Goto (Table.States (397), 151, 50);
- Add_Goto (Table.States (397), 152, 51);
- Add_Goto (Table.States (397), 161, 53);
- Add_Goto (Table.States (397), 190, 57);
- Add_Goto (Table.States (397), 196, 59);
- Add_Goto (Table.States (397), 217, 68);
- Add_Goto (Table.States (397), 222, 70);
- Add_Goto (Table.States (397), 232, 72);
- Add_Goto (Table.States (397), 239, 73);
- Add_Goto (Table.States (397), 257, 83);
- Add_Goto (Table.States (397), 261, 86);
- Add_Goto (Table.States (397), 272, 92);
- Add_Goto (Table.States (397), 276, 93);
- Add_Goto (Table.States (397), 290, 96);
- Add_Goto (Table.States (397), 293, 97);
- Add_Goto (Table.States (397), 294, 98);
- Add_Goto (Table.States (397), 298, 99);
- Add_Goto (Table.States (397), 299, 361);
- Add_Goto (Table.States (397), 300, 564);
- Add_Goto (Table.States (397), 302, 100);
- Add_Goto (Table.States (397), 303, 101);
- Add_Goto (Table.States (397), 306, 363);
- Add_Goto (Table.States (397), 323, 114);
- Table.States (397).Kernel := To_Vector ((0 => (232, 37, 3,
False)));
- Table.States (397).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 300, 0)));
- Table.States (398).Action_List.Set_Capacity (6);
- Add_Action (Table.States (398), 35, Reduce, (122, 1), 0, null,
null);
- Add_Action (Table.States (398), 74, 337);
- Add_Action (Table.States (398), 76, 235);
- Add_Action (Table.States (398), 84, 237);
- Add_Action (Table.States (398), 101, 239);
- Add_Action (Table.States (398), 102, 240);
- Table.States (398).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (398), 115, 241);
- Add_Goto (Table.States (398), 122, 338);
- Add_Goto (Table.States (398), 322, 242);
- Table.States (398).Kernel := To_Vector (((128, 239, 2, True),
(239, 239, 5, True), (239, 239, 2, True),
- (251, 239, 3, False), (251, 239, 2, False), (272, 239, 3, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True), (293, 239, 2, True)));
- Table.States (398).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (399).Action_List.Set_Capacity (40);
- Add_Action (Table.States (399), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (214, 0), 3,
+ Table.States (393).Action_List.Set_Capacity (18);
+ Add_Action (Table.States (393), 13, Reduce, (160, 0), 1, null,
null);
+ Add_Action (Table.States (393), 24, Reduce, (160, 0), 1, null,
null);
+ Add_Action (Table.States (393), 25, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (393), 28, 184);
+ Add_Action (Table.States (393), 29, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (393), 30, 8);
+ Add_Action (Table.States (393), 40, 12);
+ Add_Action (Table.States (393), 46, 14);
+ Add_Action (Table.States (393), 47, 15);
+ Add_Action (Table.States (393), 48, 16);
+ Add_Action (Table.States (393), 49, Reduce, (160, 0), 1, null,
null);
+ Add_Action (Table.States (393), 50, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (393), 51, 19);
+ Add_Action (Table.States (393), 63, 25);
+ Add_Action (Table.States (393), 66, 26);
+ Add_Action (Table.States (393), 69, 27);
+ Add_Action (Table.States (393), 71, 28);
+ Add_Action (Table.States (393), 105, 186);
+ Table.States (393).Goto_List.Set_Capacity (51);
+ Add_Goto (Table.States (393), 113, 36);
+ Add_Goto (Table.States (393), 122, 38);
+ Add_Goto (Table.States (393), 128, 41);
+ Add_Goto (Table.States (393), 135, 46);
+ Add_Goto (Table.States (393), 136, 47);
+ Add_Goto (Table.States (393), 158, 564);
+ Add_Goto (Table.States (393), 180, 55);
+ Add_Goto (Table.States (393), 183, 56);
+ Add_Goto (Table.States (393), 187, 57);
+ Add_Goto (Table.States (393), 194, 59);
+ Add_Goto (Table.States (393), 207, 61);
+ Add_Goto (Table.States (393), 208, 62);
+ Add_Goto (Table.States (393), 210, 63);
+ Add_Goto (Table.States (393), 211, 64);
+ Add_Goto (Table.States (393), 214, 65);
+ Add_Goto (Table.States (393), 215, 66);
+ Add_Goto (Table.States (393), 216, 67);
+ Add_Goto (Table.States (393), 217, 68);
+ Add_Goto (Table.States (393), 220, 70);
+ Add_Goto (Table.States (393), 224, 72);
+ Add_Goto (Table.States (393), 244, 75);
+ Add_Goto (Table.States (393), 245, 76);
+ Add_Goto (Table.States (393), 246, 77);
+ Add_Goto (Table.States (393), 247, 78);
+ Add_Goto (Table.States (393), 248, 79);
+ Add_Goto (Table.States (393), 249, 80);
+ Add_Goto (Table.States (393), 250, 81);
+ Add_Goto (Table.States (393), 251, 82);
+ Add_Goto (Table.States (393), 252, 83);
+ Add_Goto (Table.States (393), 258, 565);
+ Add_Goto (Table.States (393), 260, 85);
+ Add_Goto (Table.States (393), 261, 86);
+ Add_Goto (Table.States (393), 263, 88);
+ Add_Goto (Table.States (393), 264, 89);
+ Add_Goto (Table.States (393), 265, 90);
+ Add_Goto (Table.States (393), 266, 91);
+ Add_Goto (Table.States (393), 272, 92);
+ Add_Goto (Table.States (393), 282, 95);
+ Add_Goto (Table.States (393), 290, 96);
+ Add_Goto (Table.States (393), 305, 103);
+ Add_Goto (Table.States (393), 306, 104);
+ Add_Goto (Table.States (393), 308, 106);
+ Add_Goto (Table.States (393), 309, 107);
+ Add_Goto (Table.States (393), 310, 108);
+ Add_Goto (Table.States (393), 312, 109);
+ Add_Goto (Table.States (393), 314, 110);
+ Add_Goto (Table.States (393), 317, 112);
+ Add_Goto (Table.States (393), 318, 113);
+ Add_Goto (Table.States (393), 320, 114);
+ Add_Goto (Table.States (393), 326, 116);
+ Add_Goto (Table.States (393), 332, 117);
+ Table.States (393).Kernel := To_Vector (((159, 159, 3, True),
(159, 159, 3, True), (160, 159, 0, False)));
+ Table.States (393).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 160, 1)));
+ Table.States (394).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (394), 13, 566);
+ Table.States (394).Kernel := To_Vector ((0 => (134, 160, 3,
False)));
+ Table.States (394).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 13, 566)));
+ Table.States (395).Action_List.Set_Capacity (18);
+ Add_Action (Table.States (395), (13, 24, 25, 28, 29, 30, 40, 46,
47, 48, 49, 50, 51, 63, 66, 69, 71, 105),
+ (159, 3), 1, null, null);
+ Table.States (395).Kernel := To_Vector ((0 => (159, 258, 0,
False)));
+ Table.States (395).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 159, 1)));
+ Table.States (396).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (396), 33, 312);
+ Add_Action (Table.States (396), 42, 313);
+ Add_Action (Table.States (396), 82, 314);
+ Table.States (396).Kernel := To_Vector (((231, 105, 5, False),
(231, 105, 4, False), (231, 105, 3, False),
+ (231, 105, 3, False), (231, 105, 2, False), (231, 105, 2, False)));
+ Table.States (396).Minimal_Complete_Actions := To_Vector (((Shift,
42, 313), (Shift, 33, 312)));
+ Table.States (397).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (397), 24, 567);
+ Table.States (397).Kernel := To_Vector ((0 => (233, 301, 3,
False)));
+ Table.States (397).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 567)));
+ Table.States (398).Action_List.Set_Capacity (24);
+ Add_Action (Table.States (398), 4, 1);
+ Add_Action (Table.States (398), 5, 2);
+ Add_Action (Table.States (398), 13, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (398), 15, 3);
+ Add_Action (Table.States (398), 17, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (398), 18, 4);
+ Add_Action (Table.States (398), 24, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (398), 27, 5);
+ Add_Action (Table.States (398), 28, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (398), 31, 9);
+ Add_Action (Table.States (398), 32, 10);
+ Add_Action (Table.States (398), 37, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (398), 41, 13);
+ Add_Action (Table.States (398), 48, 16);
+ Add_Action (Table.States (398), 52, 20);
+ Add_Action (Table.States (398), 57, 21);
+ Add_Action (Table.States (398), 58, 22);
+ Add_Action (Table.States (398), 61, 24);
+ Add_Action (Table.States (398), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (398), 79, 31);
+ Add_Action (Table.States (398), 94, 32);
+ Add_Action (Table.States (398), 105, 361);
+ Add_Action (Table.States (398), 106, 34);
+ Add_Action (Table.States (398), 107, 35);
+ Table.States (398).Goto_List.Set_Capacity (31);
+ Add_Goto (Table.States (398), 114, 37);
+ Add_Goto (Table.States (398), 124, 39);
+ Add_Goto (Table.States (398), 127, 40);
+ Add_Goto (Table.States (398), 129, 42);
+ Add_Goto (Table.States (398), 132, 43);
+ Add_Goto (Table.States (398), 133, 44);
+ Add_Goto (Table.States (398), 134, 45);
+ Add_Goto (Table.States (398), 140, 48);
+ Add_Goto (Table.States (398), 152, 51);
+ Add_Goto (Table.States (398), 153, 52);
+ Add_Goto (Table.States (398), 162, 54);
+ Add_Goto (Table.States (398), 191, 58);
+ Add_Goto (Table.States (398), 197, 60);
+ Add_Goto (Table.States (398), 218, 69);
+ Add_Goto (Table.States (398), 223, 71);
+ Add_Goto (Table.States (398), 233, 73);
+ Add_Goto (Table.States (398), 240, 74);
+ Add_Goto (Table.States (398), 258, 84);
+ Add_Goto (Table.States (398), 262, 87);
+ Add_Goto (Table.States (398), 273, 93);
+ Add_Goto (Table.States (398), 277, 94);
+ Add_Goto (Table.States (398), 291, 97);
+ Add_Goto (Table.States (398), 294, 98);
+ Add_Goto (Table.States (398), 295, 99);
+ Add_Goto (Table.States (398), 299, 100);
+ Add_Goto (Table.States (398), 300, 362);
+ Add_Goto (Table.States (398), 301, 568);
+ Add_Goto (Table.States (398), 303, 101);
+ Add_Goto (Table.States (398), 304, 102);
+ Add_Goto (Table.States (398), 307, 364);
+ Add_Goto (Table.States (398), 324, 115);
+ Table.States (398).Kernel := To_Vector ((0 => (233, 37, 3,
False)));
+ Table.States (398).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 301, 0)));
+ Table.States (399).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (399), 35, Reduce, (123, 1), 0, null,
null);
+ Add_Action (Table.States (399), 74, 338);
+ Add_Action (Table.States (399), 76, 236);
+ Add_Action (Table.States (399), 85, 238);
+ Add_Action (Table.States (399), 102, 240);
+ Add_Action (Table.States (399), 103, 241);
+ Table.States (399).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (399), 116, 242);
+ Add_Goto (Table.States (399), 123, 339);
+ Add_Goto (Table.States (399), 323, 243);
+ Table.States (399).Kernel := To_Vector (((129, 240, 2, True),
(240, 240, 5, True), (240, 240, 2, True),
+ (252, 240, 3, False), (252, 240, 2, False), (273, 240, 3, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True), (294, 240, 2, True)));
+ Table.States (399).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (400).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (400), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (215, 0), 3,
generic_package_declaration_0'Access, null);
- Table.States (399).Kernel := To_Vector ((0 => (214, 96, 0,
False)));
- Table.States (399).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 214, 3)));
- Table.States (400).Action_List.Set_Capacity (1);
- Add_Action (Table.States (400), 96, 565);
- Table.States (400).Kernel := To_Vector ((0 => (216, 122, 1,
False)));
- Table.States (400).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 565)));
- Table.States (401).Action_List.Set_Capacity (14);
- Add_Action (Table.States (401), (7, 11, 16, 21, 33, 40, 45, 74,
77, 82, 96, 104, 105, 106), (118, 0), 1,
- null, null);
- Table.States (401).Kernel := To_Vector ((0 => (118, 8, 0, False)));
- Table.States (401).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 118, 1)));
- Table.States (402).Action_List.Set_Capacity (1);
- Add_Action (Table.States (402), 82, 566);
- Table.States (402).Kernel := To_Vector ((0 => (157, 16, 2,
False)));
- Table.States (402).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 82, 566)));
+ Table.States (400).Kernel := To_Vector ((0 => (215, 97, 0,
False)));
+ Table.States (400).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 215, 3)));
+ Table.States (401).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (401), 97, 569);
+ Table.States (401).Kernel := To_Vector ((0 => (217, 123, 1,
False)));
+ Table.States (401).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 569)));
+ Table.States (402).Action_List.Set_Capacity (15);
+ Add_Action (Table.States (402), (7, 11, 16, 21, 33, 40, 45, 74,
77, 79, 83, 97, 105, 106, 107), (119, 0),
+ 1, null, null);
+ Table.States (402).Kernel := To_Vector ((0 => (119, 8, 0, False)));
+ Table.States (402).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 119, 1)));
Table.States (403).Action_List.Set_Capacity (1);
- Add_Action (Table.States (403), 96, 567);
- Table.States (403).Kernel := To_Vector ((0 => (186, 26, 1,
False)));
- Table.States (403).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 567)));
- Table.States (404).Action_List.Set_Capacity (10);
- Add_Action (Table.States (404), 7, Reduce, (154, 1), 0, null,
null);
- Add_Action (Table.States (404), 11, Reduce, (154, 1), 0, null,
null);
- Add_Action (Table.States (404), 16, 568);
- Add_Action (Table.States (404), 40, Reduce, (154, 1), 0, null,
null);
- Add_Action (Table.States (404), 74, Reduce, (154, 1), 0, null,
null);
- Add_Action (Table.States (404), 82, Reduce, (154, 1), 0, null,
null);
- Add_Action (Table.States (404), 96, Reduce, (154, 1), 0, null,
null);
- Add_Action (Table.States (404), 104, Reduce, (154, 1), 0, null,
null);
- Add_Action (Table.States (404), 105, Reduce, (154, 1), 0, null,
null);
- Add_Action (Table.States (404), 106, Reduce, (154, 1), 0, null,
null);
- Table.States (404).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (404), 154, 569);
- Table.States (404).Kernel := To_Vector (((244, 118, 3, False),
(244, 118, 4, False), (244, 118, 10, False),
- (244, 118, 2, False), (244, 118, 3, False), (244, 118, 9, False)));
- Table.States (404).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 154, 0)));
- Table.States (405).Action_List.Set_Capacity (2);
- Add_Action (Table.States (405), (81, 83), (219, 0), 3,
identifier_list_0'Access, null);
- Table.States (405).Kernel := To_Vector ((0 => (219, 104, 0,
True)));
- Table.States (405).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 219, 3)));
- Table.States (405).Minimal_Complete_Actions_Recursive := True;
+ Add_Action (Table.States (403), 83, 570);
+ Table.States (403).Kernel := To_Vector ((0 => (158, 16, 2,
False)));
+ Table.States (403).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 83, 570)));
+ Table.States (404).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (404), 97, 571);
+ Table.States (404).Kernel := To_Vector ((0 => (187, 26, 1,
False)));
+ Table.States (404).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 571)));
+ Table.States (405).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (405), 7, Reduce, (155, 1), 0, null,
null);
+ Add_Action (Table.States (405), 11, Reduce, (155, 1), 0, null,
null);
+ Add_Action (Table.States (405), 16, 572);
+ Add_Action (Table.States (405), 40, Reduce, (155, 1), 0, null,
null);
+ Add_Action (Table.States (405), 74, Reduce, (155, 1), 0, null,
null);
+ Add_Action (Table.States (405), 79, Reduce, (155, 1), 0, null,
null);
+ Add_Action (Table.States (405), 83, Reduce, (155, 1), 0, null,
null);
+ Add_Action (Table.States (405), 97, Reduce, (155, 1), 0, null,
null);
+ Add_Action (Table.States (405), 105, Reduce, (155, 1), 0, null,
null);
+ Add_Action (Table.States (405), 106, Reduce, (155, 1), 0, null,
null);
+ Add_Action (Table.States (405), 107, Reduce, (155, 1), 0, null,
null);
+ Table.States (405).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (405), 155, 573);
+ Table.States (405).Kernel := To_Vector (((245, 119, 3, False),
(245, 119, 4, False), (245, 119, 10, False),
+ (245, 119, 2, False), (245, 119, 3, False), (245, 119, 9, False)));
+ Table.States (405).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 155, 0)));
Table.States (406).Action_List.Set_Capacity (2);
- Add_Action (Table.States (406), 77, 570);
- Add_Action (Table.States (406), 83, 443);
- Table.States (406).Kernel := To_Vector (((115, 125, 1, False),
(125, 125, 1, True)));
- Table.States (406).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 570)));
- Table.States (407).Action_List.Set_Capacity (1);
- Add_Action (Table.States (407), 77, 571);
- Table.States (407).Kernel := To_Vector ((0 => (115, 153, 1,
False)));
- Table.States (407).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 571)));
- Table.States (408).Action_List.Set_Capacity (6);
- Add_Action (Table.States (408), 35, Reduce, (124, 4), 1,
association_opt_4'Access, null);
- Add_Action (Table.States (408), 77, Reduce, (124, 4), 1,
association_opt_4'Access, null);
- Add_Action (Table.States (408), 79, Reduce, (165, 0), 1, null,
null);
- Add_Action (Table.States (408), 83, Reduce, (124, 4), 1,
association_opt_4'Access, null);
- Add_Action (Table.States (408), 87, Reduce, (165, 0), 1, null,
null);
- Add_Action (Table.States (408), 96, Reduce, (124, 4), 1,
association_opt_4'Access, null);
- Table.States (408).Kernel := To_Vector (((124, 191, 0, False),
(165, 191, 0, False)));
- Table.States (408).Minimal_Complete_Actions := To_Vector
(((Reduce, 124, 1), (Reduce, 165, 1)));
- Table.States (409).Action_List.Set_Capacity (4);
- Add_Action (Table.States (409), 77, Reduce, (278, 1), 1, null,
null);
- Add_Action (Table.States (409), 79, Reduce, (165, 2), 1, null,
null);
- Add_Action (Table.States (409), 83, Reduce, (278, 1), 1, null,
null);
- Add_Action (Table.States (409), 87, Reduce, (165, 2), 1, null,
null);
- Table.States (409).Kernel := To_Vector (((165, 277, 0, False),
(278, 277, 0, False)));
- Table.States (409).Minimal_Complete_Actions := To_Vector
(((Reduce, 165, 1), (Reduce, 278, 1)));
- Table.States (410).Action_List.Set_Capacity (2);
- Add_Action (Table.States (410), 77, 572);
- Add_Action (Table.States (410), 83, 573);
- Table.States (410).Kernel := To_Vector (((239, 278, 1, True),
(278, 278, 4, True)));
- Table.States (410).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 572)));
- Table.States (410).Minimal_Complete_Actions_Recursive := True;
- Table.States (411).Action_List.Set_Capacity (1);
- Add_Action (Table.States (411), 96, 574);
- Table.States (411).Kernel := To_Vector ((0 => (123, 192, 1,
False)));
- Table.States (411).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 574)));
- Table.States (412).Action_List.Set_Capacity (63);
- Add_Action (Table.States (412), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
- 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
- 88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104,
105, 106), (293, 3), 3,
- selected_component_3'Access, null);
- Table.States (412).Kernel := To_Vector ((0 => (293, 9, 0, True)));
- Table.States (412).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 293, 3)));
- Table.States (412).Minimal_Complete_Actions_Recursive := True;
- Table.States (413).Action_List.Set_Capacity (63);
+ Add_Action (Table.States (406), (82, 84), (220, 0), 3,
identifier_list_0'Access, null);
+ Table.States (406).Kernel := To_Vector ((0 => (220, 105, 0,
True)));
+ Table.States (406).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 220, 3)));
+ Table.States (406).Minimal_Complete_Actions_Recursive := True;
+ Table.States (407).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (407), 77, 574);
+ Add_Action (Table.States (407), 84, 445);
+ Table.States (407).Kernel := To_Vector (((116, 126, 1, False),
(126, 126, 1, True)));
+ Table.States (407).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 574)));
+ Table.States (408).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (408), 77, 575);
+ Table.States (408).Kernel := To_Vector ((0 => (116, 154, 1,
False)));
+ Table.States (408).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 575)));
+ Table.States (409).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (409), 35, Reduce, (125, 5), 1,
association_opt_5'Access, null);
+ Add_Action (Table.States (409), 77, Reduce, (125, 5), 1,
association_opt_5'Access, null);
+ Add_Action (Table.States (409), 80, Reduce, (166, 0), 1, null,
null);
+ Add_Action (Table.States (409), 84, Reduce, (125, 5), 1,
association_opt_5'Access, null);
+ Add_Action (Table.States (409), 88, Reduce, (166, 0), 1, null,
null);
+ Add_Action (Table.States (409), 97, Reduce, (125, 5), 1,
association_opt_5'Access, null);
+ Table.States (409).Kernel := To_Vector (((125, 192, 0, False),
(166, 192, 0, False)));
+ Table.States (409).Minimal_Complete_Actions := To_Vector
(((Reduce, 125, 1), (Reduce, 166, 1)));
+ Table.States (410).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (410), 77, Reduce, (279, 1), 1, null,
null);
+ Add_Action (Table.States (410), 80, Reduce, (166, 2), 1, null,
null);
+ Add_Action (Table.States (410), 84, Reduce, (279, 1), 1, null,
null);
+ Add_Action (Table.States (410), 88, Reduce, (166, 2), 1, null,
null);
+ Table.States (410).Kernel := To_Vector (((166, 278, 0, False),
(279, 278, 0, False)));
+ Table.States (410).Minimal_Complete_Actions := To_Vector
(((Reduce, 166, 1), (Reduce, 279, 1)));
+ Table.States (411).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (411), 77, 576);
+ Add_Action (Table.States (411), 84, 577);
+ Table.States (411).Kernel := To_Vector (((240, 279, 1, True),
(279, 279, 4, True)));
+ Table.States (411).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 576)));
+ Table.States (411).Minimal_Complete_Actions_Recursive := True;
+ Table.States (412).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (412), 97, 578);
+ Table.States (412).Kernel := To_Vector ((0 => (124, 193, 1,
False)));
+ Table.States (412).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 578)));
+ Table.States (413).Action_List.Set_Capacity (64);
Add_Action (Table.States (413), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
- 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
- 88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104,
105, 106), (293, 0), 3,
- selected_component_0'Access, selected_component_0_check'Access);
- Table.States (413).Kernel := To_Vector ((0 => (293, 104, 0,
True)));
- Table.States (413).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 293, 3)));
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+ 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
105, 106, 107), (294, 3), 3,
+ selected_component_3'Access, null);
+ Table.States (413).Kernel := To_Vector ((0 => (294, 9, 0, True)));
+ Table.States (413).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 294, 3)));
Table.States (413).Minimal_Complete_Actions_Recursive := True;
- Table.States (414).Action_List.Set_Capacity (63);
+ Table.States (414).Action_List.Set_Capacity (64);
Add_Action (Table.States (414), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
- 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
- 88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104,
105, 106), (293, 2), 3,
- selected_component_2'Access, selected_component_2_check'Access);
- Table.States (414).Kernel := To_Vector ((0 => (293, 105, 0,
True)));
- Table.States (414).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 293, 3)));
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+ 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
105, 106, 107), (294, 0), 3,
+ selected_component_0'Access, selected_component_0_check'Access);
+ Table.States (414).Kernel := To_Vector ((0 => (294, 105, 0,
True)));
+ Table.States (414).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 294, 3)));
Table.States (414).Minimal_Complete_Actions_Recursive := True;
- Table.States (415).Action_List.Set_Capacity (63);
+ Table.States (415).Action_List.Set_Capacity (64);
Add_Action (Table.States (415), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
- 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
- 88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104,
105, 106), (293, 1), 3,
- selected_component_1'Access, null);
- Table.States (415).Kernel := To_Vector ((0 => (293, 106, 0,
True)));
- Table.States (415).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 293, 3)));
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+ 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
105, 106, 107), (294, 2), 3,
+ selected_component_2'Access, selected_component_2_check'Access);
+ Table.States (415).Kernel := To_Vector ((0 => (294, 106, 0,
True)));
+ Table.States (415).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 294, 3)));
Table.States (415).Minimal_Complete_Actions_Recursive := True;
- Table.States (416).Action_List.Set_Capacity (63);
+ Table.States (416).Action_List.Set_Capacity (64);
Add_Action (Table.States (416), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
- 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
- 88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104,
105, 106), (129, 2), 1, null, null);
- Table.States (416).Kernel := To_Vector ((0 => (129, 7, 0, False)));
- Table.States (416).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 129, 1)));
- Table.States (417).Action_List.Set_Capacity (63);
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+ 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
105, 106, 107), (294, 1), 3,
+ selected_component_1'Access, null);
+ Table.States (416).Kernel := To_Vector ((0 => (294, 107, 0,
True)));
+ Table.States (416).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 294, 3)));
+ Table.States (416).Minimal_Complete_Actions_Recursive := True;
+ Table.States (417).Action_List.Set_Capacity (64);
Add_Action (Table.States (417), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
- 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
- 88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104,
105, 106), (129, 3), 1, null, null);
- Table.States (417).Kernel := To_Vector ((0 => (129, 19, 0,
False)));
- Table.States (417).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 129, 1)));
- Table.States (418).Action_List.Set_Capacity (63);
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+ 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
105, 106, 107), (130, 2), 1, null, null);
+ Table.States (417).Kernel := To_Vector ((0 => (130, 7, 0, False)));
+ Table.States (417).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 130, 1)));
+ Table.States (418).Action_List.Set_Capacity (64);
Add_Action (Table.States (418), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
- 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
- 88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104,
105, 106), (129, 4), 1, null, null);
- Table.States (418).Kernel := To_Vector ((0 => (129, 20, 0,
False)));
- Table.States (418).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 129, 1)));
- Table.States (419).Action_List.Set_Capacity (63);
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+ 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
105, 106, 107), (130, 3), 1, null, null);
+ Table.States (418).Kernel := To_Vector ((0 => (130, 19, 0,
False)));
+ Table.States (418).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 130, 1)));
+ Table.States (419).Action_List.Set_Capacity (64);
Add_Action (Table.States (419), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
- 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
- 88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104,
105, 106), (129, 5), 1, null, null);
- Table.States (419).Kernel := To_Vector ((0 => (129, 38, 0,
False)));
- Table.States (419).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 129, 1)));
- Table.States (420).Action_List.Set_Capacity (63);
- Add_Action (Table.States (420), 4, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 5, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 10, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 13, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 15, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 17, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 18, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 20, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 21, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 22, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 23, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 27, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 28, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 31, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 32, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 33, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 35, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 37, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 38, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 40, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 41, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 42, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 43, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 48, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 52, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 53, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 55, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 56, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 57, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 58, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 61, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 68, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 71, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 73, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 74, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 75, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 76, 575);
- Add_Conflict (Table.States (420), 76, (129, 1), 1, null, null);
- Add_Action (Table.States (420), 77, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 78, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 79, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 82, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 83, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 84, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 85, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 86, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 87, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 88, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 89, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 91, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 92, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 93, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 94, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 95, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 96, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 97, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 98, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 99, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 100, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 101, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 102, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 104, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 105, Reduce, (129, 1), 1, null,
null);
- Add_Action (Table.States (420), 106, Reduce, (129, 1), 1, null,
null);
- Table.States (420).Kernel := To_Vector (((129, 104, 3, False),
(129, 104, 0, False)));
- Table.States (420).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 129, 1)));
- Table.States (421).Action_List.Set_Capacity (63);
- Add_Action (Table.States (421), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
- 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
- 88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104,
105, 106), (272, 0), 3,
- qualified_expression_0'Access, null);
- Table.States (421).Kernel := To_Vector ((0 => (272, 117, 0,
True)));
- Table.States (421).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 272, 3)));
- Table.States (421).Minimal_Complete_Actions_Recursive := True;
- Table.States (422).Action_List.Set_Capacity (63);
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+ 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
105, 106, 107), (130, 4), 1, null, null);
+ Table.States (419).Kernel := To_Vector ((0 => (130, 20, 0,
False)));
+ Table.States (419).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 130, 1)));
+ Table.States (420).Action_List.Set_Capacity (64);
+ Add_Action (Table.States (420), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+ 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
105, 106, 107), (130, 5), 1, null, null);
+ Table.States (420).Kernel := To_Vector ((0 => (130, 38, 0,
False)));
+ Table.States (420).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 130, 1)));
+ Table.States (421).Action_List.Set_Capacity (64);
+ Add_Action (Table.States (421), 4, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 5, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 10, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 13, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 15, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 17, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 18, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 20, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 21, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 22, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 23, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 27, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 28, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 31, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 32, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 33, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 35, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 37, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 38, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 40, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 41, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 42, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 43, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 48, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 52, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 53, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 55, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 56, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 57, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 58, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 61, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 68, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 71, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 73, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 74, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 75, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 76, 579);
+ Add_Conflict (Table.States (421), 76, (130, 1), 1, null, null);
+ Add_Action (Table.States (421), 77, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 78, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 79, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 80, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 83, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 84, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 85, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 86, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 87, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 88, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 89, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 90, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 92, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 93, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 94, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 95, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 96, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 97, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 98, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 99, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 100, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 101, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 102, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 103, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 105, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 106, Reduce, (130, 1), 1, null,
null);
+ Add_Action (Table.States (421), 107, Reduce, (130, 1), 1, null,
null);
+ Table.States (421).Kernel := To_Vector (((130, 105, 3, False),
(130, 105, 0, False)));
+ Table.States (421).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 130, 1)));
+ Table.States (422).Action_List.Set_Capacity (64);
Add_Action (Table.States (422), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
- 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
- 88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104,
105, 106), (128, 0), 3, null, null);
- Table.States (422).Kernel := To_Vector ((0 => (128, 129, 0,
True)));
- Table.States (422).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 128, 3)));
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+ 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
105, 106, 107), (273, 0), 3,
+ qualified_expression_0'Access, null);
+ Table.States (422).Kernel := To_Vector ((0 => (273, 118, 0,
True)));
+ Table.States (422).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 273, 3)));
Table.States (422).Minimal_Complete_Actions_Recursive := True;
- Table.States (423).Action_List.Set_Capacity (3);
- Add_Action (Table.States (423), 74, Reduce, (253, 1), 0, null,
null);
- Add_Action (Table.States (423), 76, 576);
- Add_Action (Table.States (423), 96, Reduce, (253, 1), 0, null,
null);
- Table.States (423).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (423), 199, 344);
- Add_Goto (Table.States (423), 253, 577);
- Table.States (423).Kernel := To_Vector (((179, 104, 4, False),
(179, 104, 1, False)));
- Table.States (423).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 253, 0)));
- Table.States (424).Action_List.Set_Capacity (6);
- Add_Action (Table.States (424), 35, 578);
- Add_Action (Table.States (424), 58, 317);
- Add_Action (Table.States (424), 76, 318);
- Add_Action (Table.States (424), 84, 237);
- Add_Action (Table.States (424), 101, 239);
- Add_Action (Table.States (424), 102, 240);
- Table.States (424).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (424), 115, 241);
- Add_Goto (Table.States (424), 199, 319);
- Add_Goto (Table.States (424), 252, 320);
- Add_Goto (Table.States (424), 291, 321);
- Add_Goto (Table.States (424), 322, 242);
- Table.States (424).Kernel := To_Vector (((128, 239, 2, True),
(207, 239, 1, False), (213, 239, 4, False),
- (239, 239, 5, True), (239, 239, 2, True), (272, 239, 3, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True), (293, 239, 2, True)));
- Table.States (424).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 58, 317)));
- Table.States (425).Action_List.Set_Capacity (8);
- Add_Action (Table.States (425), 35, 579);
- Add_Conflict (Table.States (425), 35, (253, 1), 0, null, null);
- Add_Action (Table.States (425), 56, Reduce, (253, 1), 0, null,
null);
- Add_Action (Table.States (425), 74, Reduce, (253, 1), 0, null,
null);
- Add_Action (Table.States (425), 76, 318);
- Add_Action (Table.States (425), 84, 237);
- Add_Action (Table.States (425), 96, Reduce, (253, 1), 0, null,
null);
- Add_Action (Table.States (425), 101, 239);
+ Table.States (423).Action_List.Set_Capacity (64);
+ Add_Action (Table.States (423), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+ 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
105, 106, 107), (129, 0), 3, null, null);
+ Table.States (423).Kernel := To_Vector ((0 => (129, 130, 0,
True)));
+ Table.States (423).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 129, 3)));
+ Table.States (423).Minimal_Complete_Actions_Recursive := True;
+ Table.States (424).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (424), 74, Reduce, (254, 1), 0, null,
null);
+ Add_Action (Table.States (424), 76, 580);
+ Add_Action (Table.States (424), 97, Reduce, (254, 1), 0, null,
null);
+ Table.States (424).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (424), 200, 345);
+ Add_Goto (Table.States (424), 254, 581);
+ Table.States (424).Kernel := To_Vector (((180, 105, 4, False),
(180, 105, 1, False)));
+ Table.States (424).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 254, 0)));
+ Table.States (425).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (425), 35, 582);
+ Add_Action (Table.States (425), 58, 318);
+ Add_Action (Table.States (425), 76, 319);
+ Add_Action (Table.States (425), 85, 238);
Add_Action (Table.States (425), 102, 240);
- Table.States (425).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (425), 115, 241);
- Add_Goto (Table.States (425), 199, 344);
- Add_Goto (Table.States (425), 253, 345);
- Add_Goto (Table.States (425), 322, 242);
- Table.States (425).Kernel := To_Vector (((128, 239, 2, True),
(213, 239, 4, False), (239, 239, 5, True),
- (239, 239, 2, True), (262, 239, 0, False), (272, 239, 3, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True), (293, 239, 2, True)));
- Table.States (425).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 253, 0)));
- Table.States (426).Action_List.Set_Capacity (1);
- Add_Action (Table.States (426), 76, 580);
- Table.States (426).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (426), 117, 581);
- Add_Goto (Table.States (426), 256, 582);
- Table.States (426).Kernel := To_Vector ((0 => (193, 35, 3,
False)));
- Table.States (426).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 76, 580)));
+ Add_Action (Table.States (425), 103, 241);
+ Table.States (425).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (425), 116, 242);
+ Add_Goto (Table.States (425), 200, 320);
+ Add_Goto (Table.States (425), 253, 321);
+ Add_Goto (Table.States (425), 292, 322);
+ Add_Goto (Table.States (425), 323, 243);
+ Table.States (425).Kernel := To_Vector (((129, 240, 2, True),
(208, 240, 1, False), (214, 240, 4, False),
+ (240, 240, 5, True), (240, 240, 2, True), (273, 240, 3, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True), (294, 240, 2, True)));
+ Table.States (425).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 58, 318)));
+ Table.States (426).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (426), 35, 583);
+ Add_Conflict (Table.States (426), 35, (254, 1), 0, null, null);
+ Add_Action (Table.States (426), 56, Reduce, (254, 1), 0, null,
null);
+ Add_Action (Table.States (426), 74, Reduce, (254, 1), 0, null,
null);
+ Add_Action (Table.States (426), 76, 319);
+ Add_Action (Table.States (426), 85, 238);
+ Add_Action (Table.States (426), 97, Reduce, (254, 1), 0, null,
null);
+ Add_Action (Table.States (426), 102, 240);
+ Add_Action (Table.States (426), 103, 241);
+ Table.States (426).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (426), 116, 242);
+ Add_Goto (Table.States (426), 200, 345);
+ Add_Goto (Table.States (426), 254, 346);
+ Add_Goto (Table.States (426), 323, 243);
+ Table.States (426).Kernel := To_Vector (((129, 240, 2, True),
(214, 240, 4, False), (240, 240, 5, True),
+ (240, 240, 2, True), (263, 240, 0, False), (273, 240, 3, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True), (294, 240, 2, True)));
+ Table.States (426).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 254, 0)));
Table.States (427).Action_List.Set_Capacity (1);
- Add_Action (Table.States (427), 41, 583);
- Table.States (427).Kernel := To_Vector ((0 => (243, 35, 2,
False)));
- Table.States (427).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 41, 583)));
- Table.States (428).Action_List.Set_Capacity (2);
- Add_Action (Table.States (428), 6, 584);
- Add_Action (Table.States (428), 60, 585);
- Table.States (428).Kernel := To_Vector (((112, 35, 2, False),
(308, 35, 2, False)));
- Table.States (428).Minimal_Complete_Actions := To_Vector (((Shift,
6, 584), (Shift, 60, 585)));
- Table.States (429).Action_List.Set_Capacity (3);
- Add_Action (Table.States (429), 104, 119);
- Add_Action (Table.States (429), 105, 33);
- Add_Action (Table.States (429), 106, 34);
- Table.States (429).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (429), 128, 41);
- Add_Goto (Table.States (429), 239, 586);
- Add_Goto (Table.States (429), 272, 92);
- Add_Goto (Table.States (429), 293, 97);
- Table.States (429).Kernel := To_Vector ((0 => (311, 56, 2,
False)));
- Table.States (429).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (430).Action_List.Set_Capacity (2);
- Add_Action (Table.States (430), 35, 587);
- Add_Action (Table.States (430), 96, 588);
- Table.States (430).Kernel := To_Vector (((307, 122, 4, False),
(309, 122, 1, False)));
- Table.States (430).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 588)));
- Table.States (431).Action_List.Set_Capacity (3);
- Add_Action (Table.States (431), 77, Reduce, (254, 4), 0, null,
null);
- Add_Action (Table.States (431), 96, Reduce, (254, 4), 0, null,
null);
- Add_Action (Table.States (431), 104, 164);
- Table.States (431).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (431), 219, 493);
- Add_Goto (Table.States (431), 254, 494);
- Add_Goto (Table.States (431), 255, 495);
- Table.States (431).Kernel := To_Vector ((0 => (199, 76, 1,
False)));
- Table.States (431).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 255, 0)));
- Table.States (432).Action_List.Set_Capacity (2);
- Add_Action (Table.States (432), 21, 589);
- Add_Action (Table.States (432), 96, 590);
- Table.States (432).Kernel := To_Vector (((113, 253, 3, False),
(113, 253, 1, False)));
- Table.States (432).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 590)));
- Table.States (433).Action_List.Set_Capacity (29);
- Add_Action (Table.States (433), 3, 121);
- Add_Action (Table.States (433), 10, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (433), 20, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (433), 21, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (433), 22, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (433), 23, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (433), 35, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (433), 37, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (433), 39, 122);
- Add_Action (Table.States (433), 40, 123);
- Add_Action (Table.States (433), 41, 124);
- Add_Action (Table.States (433), 43, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (433), 52, 125);
- Add_Action (Table.States (433), 53, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (433), 68, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (433), 74, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (433), 75, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (433), 76, 126);
- Add_Action (Table.States (433), 77, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (433), 79, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (433), 83, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (433), 87, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (433), 94, 127);
- Add_Action (Table.States (433), 95, 128);
- Add_Action (Table.States (433), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (433), 103, 129);
- Add_Action (Table.States (433), 104, 119);
- Add_Action (Table.States (433), 105, 33);
- Add_Action (Table.States (433), 106, 34);
- Table.States (433).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (433), 117, 130);
- Add_Goto (Table.States (433), 128, 41);
- Add_Goto (Table.States (433), 191, 131);
- Add_Goto (Table.States (433), 192, 591);
- Add_Goto (Table.States (433), 197, 133);
- Add_Goto (Table.States (433), 239, 134);
- Add_Goto (Table.States (433), 258, 135);
- Add_Goto (Table.States (433), 272, 92);
- Add_Goto (Table.States (433), 275, 136);
- Add_Goto (Table.States (433), 282, 137);
- Add_Goto (Table.States (433), 283, 138);
- Add_Goto (Table.States (433), 284, 139);
- Add_Goto (Table.States (433), 285, 140);
- Add_Goto (Table.States (433), 286, 141);
- Add_Goto (Table.States (433), 287, 142);
- Add_Goto (Table.States (433), 293, 97);
- Add_Goto (Table.States (433), 301, 143);
- Add_Goto (Table.States (433), 320, 144);
- Add_Goto (Table.States (433), 321, 145);
- Add_Goto (Table.States (433), 330, 146);
- Table.States (433).Kernel := To_Vector ((0 => (275, 74, 0, True)));
- Table.States (433).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (433).Minimal_Complete_Actions_Recursive := True;
- Table.States (434).Action_List.Set_Capacity (1);
- Add_Action (Table.States (434), 35, 592);
- Table.States (434).Kernel := To_Vector ((0 => (136, 192, 3,
False)));
- Table.States (434).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 592)));
+ Add_Action (Table.States (427), 76, 584);
+ Table.States (427).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (427), 118, 585);
+ Add_Goto (Table.States (427), 257, 586);
+ Table.States (427).Kernel := To_Vector ((0 => (194, 35, 3,
False)));
+ Table.States (427).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 76, 584)));
+ Table.States (428).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (428), 41, 587);
+ Table.States (428).Kernel := To_Vector ((0 => (244, 35, 2,
False)));
+ Table.States (428).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 41, 587)));
+ Table.States (429).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (429), 6, 588);
+ Add_Action (Table.States (429), 60, 589);
+ Table.States (429).Kernel := To_Vector (((113, 35, 2, False),
(309, 35, 2, False)));
+ Table.States (429).Minimal_Complete_Actions := To_Vector (((Shift,
6, 588), (Shift, 60, 589)));
+ Table.States (430).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (430), 79, 31);
+ Add_Action (Table.States (430), 105, 120);
+ Add_Action (Table.States (430), 106, 34);
+ Add_Action (Table.States (430), 107, 35);
+ Table.States (430).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (430), 129, 42);
+ Add_Goto (Table.States (430), 240, 590);
+ Add_Goto (Table.States (430), 273, 93);
+ Add_Goto (Table.States (430), 294, 98);
+ Table.States (430).Kernel := To_Vector ((0 => (312, 56, 2,
False)));
+ Table.States (430).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (431).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (431), 35, 591);
+ Add_Action (Table.States (431), 97, 592);
+ Table.States (431).Kernel := To_Vector (((308, 123, 4, False),
(310, 123, 1, False)));
+ Table.States (431).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 592)));
+ Table.States (432).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (432), 77, Reduce, (255, 4), 0, null,
null);
+ Add_Action (Table.States (432), 97, Reduce, (255, 4), 0, null,
null);
+ Add_Action (Table.States (432), 105, 165);
+ Table.States (432).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (432), 220, 496);
+ Add_Goto (Table.States (432), 255, 497);
+ Add_Goto (Table.States (432), 256, 498);
+ Table.States (432).Kernel := To_Vector ((0 => (200, 76, 1,
False)));
+ Table.States (432).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 256, 0)));
+ Table.States (433).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (433), 21, 593);
+ Add_Action (Table.States (433), 97, 594);
+ Table.States (433).Kernel := To_Vector (((114, 254, 3, False),
(114, 254, 1, False)));
+ Table.States (433).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 594)));
+ Table.States (434).Action_List.Set_Capacity (30);
+ Add_Action (Table.States (434), 3, 122);
+ Add_Action (Table.States (434), 10, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (434), 20, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (434), 21, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (434), 22, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (434), 23, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (434), 35, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (434), 37, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (434), 39, 123);
+ Add_Action (Table.States (434), 40, 124);
+ Add_Action (Table.States (434), 41, 125);
+ Add_Action (Table.States (434), 43, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (434), 52, 126);
+ Add_Action (Table.States (434), 53, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (434), 68, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (434), 74, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (434), 75, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (434), 76, 127);
+ Add_Action (Table.States (434), 77, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (434), 79, 31);
+ Add_Action (Table.States (434), 80, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (434), 84, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (434), 88, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (434), 95, 128);
+ Add_Action (Table.States (434), 96, 129);
+ Add_Action (Table.States (434), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (434), 104, 130);
+ Add_Action (Table.States (434), 105, 120);
+ Add_Action (Table.States (434), 106, 34);
+ Add_Action (Table.States (434), 107, 35);
+ Table.States (434).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (434), 118, 131);
+ Add_Goto (Table.States (434), 129, 42);
+ Add_Goto (Table.States (434), 192, 132);
+ Add_Goto (Table.States (434), 193, 595);
+ Add_Goto (Table.States (434), 198, 134);
+ Add_Goto (Table.States (434), 240, 135);
+ Add_Goto (Table.States (434), 259, 136);
+ Add_Goto (Table.States (434), 273, 93);
+ Add_Goto (Table.States (434), 276, 137);
+ Add_Goto (Table.States (434), 283, 138);
+ Add_Goto (Table.States (434), 284, 139);
+ Add_Goto (Table.States (434), 285, 140);
+ Add_Goto (Table.States (434), 286, 141);
+ Add_Goto (Table.States (434), 287, 142);
+ Add_Goto (Table.States (434), 288, 143);
+ Add_Goto (Table.States (434), 294, 98);
+ Add_Goto (Table.States (434), 302, 144);
+ Add_Goto (Table.States (434), 321, 145);
+ Add_Goto (Table.States (434), 322, 146);
+ Add_Goto (Table.States (434), 331, 147);
+ Table.States (434).Kernel := To_Vector ((0 => (276, 74, 0, True)));
+ Table.States (434).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (434).Minimal_Complete_Actions_Recursive := True;
Table.States (435).Action_List.Set_Capacity (1);
- Add_Action (Table.States (435), (1 => 104), (274, 0), 1, null,
null);
- Table.States (435).Kernel := To_Vector ((0 => (274, 9, 0, False)));
- Table.States (435).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 274, 1)));
+ Add_Action (Table.States (435), 35, 596);
+ Table.States (435).Kernel := To_Vector ((0 => (137, 193, 3,
False)));
+ Table.States (435).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 596)));
Table.States (436).Action_List.Set_Capacity (1);
- Add_Action (Table.States (436), (1 => 104), (274, 1), 1, null,
null);
- Table.States (436).Kernel := To_Vector ((0 => (274, 62, 0,
False)));
- Table.States (436).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 274, 1)));
+ Add_Action (Table.States (436), (1 => 105), (275, 0), 1, null,
null);
+ Table.States (436).Kernel := To_Vector ((0 => (275, 9, 0, False)));
+ Table.States (436).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 275, 1)));
Table.States (437).Action_List.Set_Capacity (1);
- Add_Action (Table.States (437), 104, 395);
- Table.States (437).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (437), 230, 593);
- Table.States (437).Kernel := To_Vector ((0 => (273, 274, 4,
False)));
- Table.States (437).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 395)));
+ Add_Action (Table.States (437), (1 => 105), (275, 1), 1, null,
null);
+ Table.States (437).Kernel := To_Vector ((0 => (275, 62, 0,
False)));
+ Table.States (437).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 275, 1)));
Table.States (438).Action_List.Set_Capacity (1);
- Add_Action (Table.States (438), 68, 594);
- Table.States (438).Kernel := To_Vector (((221, 192, 4, False),
(221, 192, 2, False), (221, 192, 3, False),
- (221, 192, 1, False)));
- Table.States (438).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 68, 594)));
- Table.States (439).Action_List.Set_Capacity (29);
- Add_Action (Table.States (439), 10, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (439), 33, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (439), 35, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (439), 38, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (439), 40, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (439), 43, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (439), 55, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (439), 74, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (439), 75, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (439), 77, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (439), 78, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (439), 79, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (439), 83, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (439), 85, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (439), 86, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (439), 87, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (439), 88, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (439), 89, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (439), 91, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (439), 92, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (439), 94, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (439), 95, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (439), 96, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (439), 97, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (439), 98, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (439), 99, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (439), 104, 119);
- Add_Action (Table.States (439), 105, 33);
- Add_Action (Table.States (439), 106, 34);
- Table.States (439).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (439), 128, 41);
- Add_Goto (Table.States (439), 239, 595);
- Add_Goto (Table.States (439), 272, 92);
- Add_Goto (Table.States (439), 293, 97);
- Table.States (439).Kernel := To_Vector (((165, 41, 1, False),
(258, 41, 0, False)));
- Table.States (439).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 258, 1)));
+ Add_Action (Table.States (438), 33, 597);
+ Table.States (438).Kernel := To_Vector ((0 => (125, 105, 3,
False)));
+ Table.States (438).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 597)));
+ Table.States (439).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (439), 105, 396);
+ Table.States (439).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (439), 231, 598);
+ Table.States (439).Kernel := To_Vector ((0 => (274, 275, 4,
False)));
+ Table.States (439).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 396)));
Table.States (440).Action_List.Set_Capacity (1);
- Add_Action (Table.States (440), 77, 596);
- Table.States (440).Kernel := To_Vector ((0 => (117, 54, 1,
False)));
- Table.States (440).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 596)));
- Table.States (441).Action_List.Set_Capacity (17);
- Add_Action (Table.States (441), 3, 121);
- Add_Action (Table.States (441), 35, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (441), 39, 122);
- Add_Action (Table.States (441), 40, 123);
- Add_Action (Table.States (441), 41, 124);
- Add_Action (Table.States (441), 52, 125);
- Add_Action (Table.States (441), 76, 126);
- Add_Action (Table.States (441), 77, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (441), 80, 597);
- Add_Action (Table.States (441), 83, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (441), 94, 127);
- Add_Action (Table.States (441), 95, 128);
- Add_Action (Table.States (441), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (441), 103, 129);
- Add_Action (Table.States (441), 104, 119);
- Add_Action (Table.States (441), 105, 33);
+ Add_Action (Table.States (440), 68, 599);
+ Table.States (440).Kernel := To_Vector (((222, 193, 4, False),
(222, 193, 2, False), (222, 193, 3, False),
+ (222, 193, 1, False)));
+ Table.States (440).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 68, 599)));
+ Table.States (441).Action_List.Set_Capacity (30);
+ Add_Action (Table.States (441), 10, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (441), 33, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (441), 35, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (441), 38, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (441), 40, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (441), 43, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (441), 55, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (441), 74, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (441), 75, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (441), 77, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (441), 78, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (441), 79, 31);
+ Add_Action (Table.States (441), 80, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (441), 84, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (441), 86, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (441), 87, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (441), 88, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (441), 89, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (441), 90, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (441), 92, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (441), 93, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (441), 95, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (441), 96, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (441), 97, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (441), 98, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (441), 99, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (441), 100, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (441), 105, 120);
Add_Action (Table.States (441), 106, 34);
- Table.States (441).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (441), 117, 130);
- Add_Goto (Table.States (441), 128, 41);
- Add_Goto (Table.States (441), 191, 131);
- Add_Goto (Table.States (441), 192, 598);
- Add_Goto (Table.States (441), 197, 133);
- Add_Goto (Table.States (441), 239, 134);
- Add_Goto (Table.States (441), 258, 135);
- Add_Goto (Table.States (441), 272, 92);
- Add_Goto (Table.States (441), 275, 136);
- Add_Goto (Table.States (441), 282, 137);
- Add_Goto (Table.States (441), 283, 138);
- Add_Goto (Table.States (441), 284, 139);
- Add_Goto (Table.States (441), 285, 140);
- Add_Goto (Table.States (441), 286, 141);
- Add_Goto (Table.States (441), 287, 142);
- Add_Goto (Table.States (441), 293, 97);
- Add_Goto (Table.States (441), 301, 143);
- Add_Goto (Table.States (441), 320, 144);
- Add_Goto (Table.States (441), 321, 145);
- Add_Goto (Table.States (441), 330, 146);
- Table.States (441).Kernel := To_Vector (((124, 87, 0, False),
(124, 87, 1, False)));
- Table.States (441).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (442).Action_List.Set_Capacity (63);
- Add_Action (Table.States (442), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
- 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
- 88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104,
105, 106), (117, 4), 3, aggregate_4'Access,
- null);
- Table.States (442).Kernel := To_Vector ((0 => (117, 77, 0,
False)));
- Table.States (442).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 117, 3)));
- Table.States (443).Action_List.Set_Capacity (19);
- Add_Action (Table.States (443), 3, 121);
- Add_Action (Table.States (443), 35, Reduce, (124, 5), 0, null,
null);
- Add_Action (Table.States (443), 39, 122);
- Add_Action (Table.States (443), 40, 261);
- Add_Action (Table.States (443), 41, 124);
- Add_Action (Table.States (443), 44, 263);
- Add_Action (Table.States (443), 52, 125);
- Add_Action (Table.States (443), 76, 126);
- Add_Action (Table.States (443), 77, Reduce, (124, 5), 0, null,
null);
- Add_Action (Table.States (443), 79, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (443), 83, Reduce, (124, 5), 0, null,
null);
- Add_Action (Table.States (443), 87, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (443), 94, 127);
+ Add_Action (Table.States (441), 107, 35);
+ Table.States (441).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (441), 129, 42);
+ Add_Goto (Table.States (441), 240, 600);
+ Add_Goto (Table.States (441), 273, 93);
+ Add_Goto (Table.States (441), 294, 98);
+ Table.States (441).Kernel := To_Vector (((166, 41, 1, False),
(259, 41, 0, False)));
+ Table.States (441).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 259, 1)));
+ end Subr_8;
+ procedure Subr_9
+ is begin
+ Table.States (442).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (442), 77, 601);
+ Table.States (442).Kernel := To_Vector ((0 => (118, 54, 1,
False)));
+ Table.States (442).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 601)));
+ Table.States (443).Action_List.Set_Capacity (18);
+ Add_Action (Table.States (443), 3, 122);
+ Add_Action (Table.States (443), 35, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (443), 39, 123);
+ Add_Action (Table.States (443), 40, 124);
+ Add_Action (Table.States (443), 41, 125);
+ Add_Action (Table.States (443), 52, 126);
+ Add_Action (Table.States (443), 76, 127);
+ Add_Action (Table.States (443), 77, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (443), 79, 31);
+ Add_Action (Table.States (443), 81, 602);
+ Add_Action (Table.States (443), 84, Reduce, (193, 1), 0, null,
null);
Add_Action (Table.States (443), 95, 128);
- Add_Action (Table.States (443), 96, Reduce, (124, 5), 0, null,
null);
- Add_Action (Table.States (443), 103, 129);
- Add_Action (Table.States (443), 104, 119);
- Add_Action (Table.States (443), 105, 33);
- Add_Action (Table.States (443), 106, 264);
- Table.States (443).Goto_List.Set_Capacity (23);
- Add_Goto (Table.States (443), 117, 130);
- Add_Goto (Table.States (443), 124, 599);
- Add_Goto (Table.States (443), 128, 41);
- Add_Goto (Table.States (443), 165, 269);
- Add_Goto (Table.States (443), 166, 270);
- Add_Goto (Table.States (443), 191, 408);
- Add_Goto (Table.States (443), 197, 133);
- Add_Goto (Table.States (443), 239, 274);
- Add_Goto (Table.States (443), 258, 135);
- Add_Goto (Table.States (443), 272, 92);
- Add_Goto (Table.States (443), 275, 136);
- Add_Goto (Table.States (443), 277, 276);
- Add_Goto (Table.States (443), 282, 137);
+ Add_Action (Table.States (443), 96, 129);
+ Add_Action (Table.States (443), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (443), 104, 130);
+ Add_Action (Table.States (443), 105, 120);
+ Add_Action (Table.States (443), 106, 34);
+ Add_Action (Table.States (443), 107, 35);
+ Table.States (443).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (443), 118, 131);
+ Add_Goto (Table.States (443), 129, 42);
+ Add_Goto (Table.States (443), 192, 132);
+ Add_Goto (Table.States (443), 193, 603);
+ Add_Goto (Table.States (443), 198, 134);
+ Add_Goto (Table.States (443), 240, 135);
+ Add_Goto (Table.States (443), 259, 136);
+ Add_Goto (Table.States (443), 273, 93);
+ Add_Goto (Table.States (443), 276, 137);
Add_Goto (Table.States (443), 283, 138);
Add_Goto (Table.States (443), 284, 139);
Add_Goto (Table.States (443), 285, 140);
Add_Goto (Table.States (443), 286, 141);
Add_Goto (Table.States (443), 287, 142);
- Add_Goto (Table.States (443), 293, 97);
- Add_Goto (Table.States (443), 301, 277);
- Add_Goto (Table.States (443), 320, 144);
+ Add_Goto (Table.States (443), 288, 143);
+ Add_Goto (Table.States (443), 294, 98);
+ Add_Goto (Table.States (443), 302, 144);
Add_Goto (Table.States (443), 321, 145);
- Add_Goto (Table.States (443), 330, 146);
- Table.States (443).Kernel := To_Vector ((0 => (125, 83, 0, True)));
- Table.States (443).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 124, 0)));
- Table.States (443).Minimal_Complete_Actions_Recursive := True;
- Table.States (444).Action_List.Set_Capacity (63);
+ Add_Goto (Table.States (443), 322, 146);
+ Add_Goto (Table.States (443), 331, 147);
+ Table.States (443).Kernel := To_Vector (((125, 88, 0, False),
(125, 88, 1, False)));
+ Table.States (443).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (444).Action_List.Set_Capacity (64);
Add_Action (Table.States (444), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
- 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
- 88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104,
105, 106), (117, 3), 3, aggregate_3'Access,
- null);
- Table.States (444).Kernel := To_Vector ((0 => (117, 77, 0,
False)));
- Table.States (444).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 117, 3)));
- Table.States (445).Action_List.Set_Capacity (13);
- Add_Action (Table.States (445), 3, 121);
- Add_Action (Table.States (445), 39, 122);
- Add_Action (Table.States (445), 40, 261);
- Add_Action (Table.States (445), 41, 124);
- Add_Action (Table.States (445), 44, 263);
- Add_Action (Table.States (445), 52, 125);
- Add_Action (Table.States (445), 76, 126);
- Add_Action (Table.States (445), 94, 127);
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+ 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
105, 106, 107), (118, 5), 3,
+ aggregate_5'Access, null);
+ Table.States (444).Kernel := To_Vector ((0 => (118, 77, 0,
False)));
+ Table.States (444).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 118, 3)));
+ Table.States (445).Action_List.Set_Capacity (21);
+ Add_Action (Table.States (445), 3, 122);
+ Add_Action (Table.States (445), 28, 517);
+ Add_Action (Table.States (445), 35, Reduce, (125, 6), 0, null,
null);
+ Add_Action (Table.States (445), 39, 123);
+ Add_Action (Table.States (445), 40, 262);
+ Add_Action (Table.States (445), 41, 125);
+ Add_Action (Table.States (445), 44, 264);
+ Add_Action (Table.States (445), 52, 126);
+ Add_Action (Table.States (445), 76, 127);
+ Add_Action (Table.States (445), 77, Reduce, (125, 6), 0, null,
null);
+ Add_Action (Table.States (445), 79, 31);
+ Add_Action (Table.States (445), 80, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (445), 84, Reduce, (125, 6), 0, null,
null);
+ Add_Action (Table.States (445), 88, Reduce, (167, 2), 0, null,
null);
Add_Action (Table.States (445), 95, 128);
- Add_Action (Table.States (445), 103, 129);
- Add_Action (Table.States (445), 104, 119);
- Add_Action (Table.States (445), 105, 33);
+ Add_Action (Table.States (445), 96, 129);
+ Add_Action (Table.States (445), 97, Reduce, (125, 6), 0, null,
null);
+ Add_Action (Table.States (445), 104, 130);
+ Add_Action (Table.States (445), 105, 120);
Add_Action (Table.States (445), 106, 34);
- Table.States (445).Goto_List.Set_Capacity (21);
- Add_Goto (Table.States (445), 117, 130);
- Add_Goto (Table.States (445), 128, 41);
- Add_Goto (Table.States (445), 165, 600);
- Add_Goto (Table.States (445), 191, 601);
- Add_Goto (Table.States (445), 197, 133);
- Add_Goto (Table.States (445), 239, 274);
- Add_Goto (Table.States (445), 258, 135);
- Add_Goto (Table.States (445), 272, 92);
- Add_Goto (Table.States (445), 275, 136);
- Add_Goto (Table.States (445), 277, 276);
- Add_Goto (Table.States (445), 282, 137);
+ Add_Action (Table.States (445), 107, 265);
+ Table.States (445).Goto_List.Set_Capacity (23);
+ Add_Goto (Table.States (445), 118, 131);
+ Add_Goto (Table.States (445), 125, 604);
+ Add_Goto (Table.States (445), 129, 42);
+ Add_Goto (Table.States (445), 166, 270);
+ Add_Goto (Table.States (445), 167, 271);
+ Add_Goto (Table.States (445), 192, 409);
+ Add_Goto (Table.States (445), 198, 134);
+ Add_Goto (Table.States (445), 240, 275);
+ Add_Goto (Table.States (445), 259, 136);
+ Add_Goto (Table.States (445), 273, 93);
+ Add_Goto (Table.States (445), 276, 137);
+ Add_Goto (Table.States (445), 278, 277);
Add_Goto (Table.States (445), 283, 138);
Add_Goto (Table.States (445), 284, 139);
Add_Goto (Table.States (445), 285, 140);
Add_Goto (Table.States (445), 286, 141);
Add_Goto (Table.States (445), 287, 142);
- Add_Goto (Table.States (445), 293, 97);
- Add_Goto (Table.States (445), 301, 277);
- Add_Goto (Table.States (445), 320, 144);
+ Add_Goto (Table.States (445), 288, 143);
+ Add_Goto (Table.States (445), 294, 98);
+ Add_Goto (Table.States (445), 302, 278);
Add_Goto (Table.States (445), 321, 145);
- Add_Goto (Table.States (445), 330, 146);
- Table.States (445).Kernel := To_Vector ((0 => (166, 79, 1, True)));
- Table.States (445).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
+ Add_Goto (Table.States (445), 322, 146);
+ Add_Goto (Table.States (445), 331, 147);
+ Table.States (445).Kernel := To_Vector ((0 => (126, 84, 0, True)));
+ Table.States (445).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 125, 0)));
Table.States (445).Minimal_Complete_Actions_Recursive := True;
- Table.States (446).Action_List.Set_Capacity (17);
- Add_Action (Table.States (446), 3, 121);
- Add_Action (Table.States (446), 35, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (446), 39, 122);
- Add_Action (Table.States (446), 40, 123);
- Add_Action (Table.States (446), 41, 124);
- Add_Action (Table.States (446), 52, 125);
- Add_Action (Table.States (446), 76, 126);
- Add_Action (Table.States (446), 77, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (446), 80, 602);
- Add_Action (Table.States (446), 83, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (446), 94, 127);
- Add_Action (Table.States (446), 95, 128);
- Add_Action (Table.States (446), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (446), 103, 129);
- Add_Action (Table.States (446), 104, 119);
- Add_Action (Table.States (446), 105, 33);
- Add_Action (Table.States (446), 106, 34);
- Table.States (446).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (446), 117, 130);
- Add_Goto (Table.States (446), 128, 41);
- Add_Goto (Table.States (446), 191, 131);
- Add_Goto (Table.States (446), 192, 603);
- Add_Goto (Table.States (446), 197, 133);
- Add_Goto (Table.States (446), 239, 134);
- Add_Goto (Table.States (446), 258, 135);
- Add_Goto (Table.States (446), 272, 92);
- Add_Goto (Table.States (446), 275, 136);
- Add_Goto (Table.States (446), 282, 137);
- Add_Goto (Table.States (446), 283, 138);
- Add_Goto (Table.States (446), 284, 139);
- Add_Goto (Table.States (446), 285, 140);
- Add_Goto (Table.States (446), 286, 141);
- Add_Goto (Table.States (446), 287, 142);
- Add_Goto (Table.States (446), 293, 97);
- Add_Goto (Table.States (446), 301, 143);
- Add_Goto (Table.States (446), 320, 144);
- Add_Goto (Table.States (446), 321, 145);
- Add_Goto (Table.States (446), 330, 146);
- Table.States (446).Kernel := To_Vector (((124, 87, 0, False),
(124, 87, 1, False)));
- Table.States (446).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- end Subr_8;
- procedure Subr_9
- is begin
- Table.States (447).Action_List.Set_Capacity (17);
- Add_Action (Table.States (447), 3, 121);
- Add_Action (Table.States (447), 39, 122);
- Add_Action (Table.States (447), 40, 261);
- Add_Action (Table.States (447), 41, 604);
- Add_Action (Table.States (447), 44, 263);
- Add_Action (Table.States (447), 52, 125);
- Add_Action (Table.States (447), 76, 126);
- Add_Action (Table.States (447), 77, Reduce, (124, 5), 0, null,
null);
- Add_Action (Table.States (447), 79, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (447), 83, Reduce, (124, 5), 0, null,
null);
- Add_Action (Table.States (447), 87, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (447), 94, 127);
+ Table.States (446).Action_List.Set_Capacity (64);
+ Add_Action (Table.States (446), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+ 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
105, 106, 107), (118, 4), 3,
+ aggregate_4'Access, null);
+ Table.States (446).Kernel := To_Vector ((0 => (118, 77, 0,
False)));
+ Table.States (446).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 118, 3)));
+ Table.States (447).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (447), 3, 122);
+ Add_Action (Table.States (447), 39, 123);
+ Add_Action (Table.States (447), 40, 262);
+ Add_Action (Table.States (447), 41, 125);
+ Add_Action (Table.States (447), 44, 264);
+ Add_Action (Table.States (447), 52, 126);
+ Add_Action (Table.States (447), 76, 127);
+ Add_Action (Table.States (447), 79, 31);
Add_Action (Table.States (447), 95, 128);
- Add_Action (Table.States (447), 103, 129);
- Add_Action (Table.States (447), 104, 119);
- Add_Action (Table.States (447), 105, 33);
- Add_Action (Table.States (447), 106, 264);
- Table.States (447).Goto_List.Set_Capacity (24);
- Add_Goto (Table.States (447), 117, 130);
- Add_Goto (Table.States (447), 124, 265);
- Add_Goto (Table.States (447), 125, 605);
- Add_Goto (Table.States (447), 128, 41);
- Add_Goto (Table.States (447), 165, 269);
- Add_Goto (Table.States (447), 166, 270);
- Add_Goto (Table.States (447), 191, 408);
- Add_Goto (Table.States (447), 197, 133);
- Add_Goto (Table.States (447), 239, 274);
- Add_Goto (Table.States (447), 258, 135);
- Add_Goto (Table.States (447), 272, 92);
- Add_Goto (Table.States (447), 275, 136);
- Add_Goto (Table.States (447), 277, 276);
- Add_Goto (Table.States (447), 282, 137);
+ Add_Action (Table.States (447), 96, 129);
+ Add_Action (Table.States (447), 104, 130);
+ Add_Action (Table.States (447), 105, 120);
+ Add_Action (Table.States (447), 106, 34);
+ Add_Action (Table.States (447), 107, 35);
+ Table.States (447).Goto_List.Set_Capacity (21);
+ Add_Goto (Table.States (447), 118, 131);
+ Add_Goto (Table.States (447), 129, 42);
+ Add_Goto (Table.States (447), 166, 605);
+ Add_Goto (Table.States (447), 192, 606);
+ Add_Goto (Table.States (447), 198, 134);
+ Add_Goto (Table.States (447), 240, 275);
+ Add_Goto (Table.States (447), 259, 136);
+ Add_Goto (Table.States (447), 273, 93);
+ Add_Goto (Table.States (447), 276, 137);
+ Add_Goto (Table.States (447), 278, 277);
Add_Goto (Table.States (447), 283, 138);
Add_Goto (Table.States (447), 284, 139);
Add_Goto (Table.States (447), 285, 140);
Add_Goto (Table.States (447), 286, 141);
Add_Goto (Table.States (447), 287, 142);
- Add_Goto (Table.States (447), 293, 97);
- Add_Goto (Table.States (447), 301, 277);
- Add_Goto (Table.States (447), 320, 144);
+ Add_Goto (Table.States (447), 288, 143);
+ Add_Goto (Table.States (447), 294, 98);
+ Add_Goto (Table.States (447), 302, 278);
Add_Goto (Table.States (447), 321, 145);
- Add_Goto (Table.States (447), 330, 146);
- Table.States (447).Kernel := To_Vector (((117, 74, 3, False),
(117, 74, 1, False)));
- Table.States (447).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 125, 0)));
- Table.States (448).Action_List.Set_Capacity (7);
- Add_Action (Table.States (448), 7, 416);
- Add_Action (Table.States (448), 19, 417);
- Add_Action (Table.States (448), 20, 418);
- Add_Action (Table.States (448), 38, 419);
- Add_Action (Table.States (448), 53, 606);
- Add_Action (Table.States (448), 76, 126);
- Add_Action (Table.States (448), 104, 420);
- Table.States (448).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (448), 117, 421);
- Add_Goto (Table.States (448), 129, 422);
- Table.States (448).Kernel := To_Vector (((128, 322, 1, True),
(272, 322, 2, True), (277, 322, 3, False),
- (277, 322, 1, False)));
- Table.States (448).Minimal_Complete_Actions := To_Vector (((Shift,
104, 420), (Shift, 53, 606)));
- Table.States (448).Minimal_Complete_Actions_Recursive := True;
- Table.States (449).Action_List.Set_Capacity (11);
- Add_Action (Table.States (449), 3, 121);
- Add_Action (Table.States (449), 39, 122);
- Add_Action (Table.States (449), 40, 123);
- Add_Action (Table.States (449), 41, 124);
- Add_Action (Table.States (449), 76, 126);
- Add_Action (Table.States (449), 94, 127);
- Add_Action (Table.States (449), 95, 128);
- Add_Action (Table.States (449), 103, 129);
- Add_Action (Table.States (449), 104, 119);
- Add_Action (Table.States (449), 105, 33);
- Add_Action (Table.States (449), 106, 34);
- Table.States (449).Goto_List.Set_Capacity (11);
- Add_Goto (Table.States (449), 117, 130);
- Add_Goto (Table.States (449), 128, 41);
- Add_Goto (Table.States (449), 197, 133);
- Add_Goto (Table.States (449), 239, 134);
- Add_Goto (Table.States (449), 258, 135);
- Add_Goto (Table.States (449), 272, 92);
- Add_Goto (Table.States (449), 293, 97);
- Add_Goto (Table.States (449), 301, 607);
- Add_Goto (Table.States (449), 320, 144);
- Add_Goto (Table.States (449), 321, 145);
- Add_Goto (Table.States (449), 330, 146);
- Table.States (449).Kernel := To_Vector ((0 => (277, 85, 1,
False)));
- Table.States (449).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
- Table.States (450).Action_List.Set_Capacity (15);
- Add_Action (Table.States (450), 3, 121);
- Add_Action (Table.States (450), 39, 122);
- Add_Action (Table.States (450), 40, 261);
- Add_Action (Table.States (450), 41, 124);
- Add_Action (Table.States (450), 44, 263);
- Add_Action (Table.States (450), 52, 125);
- Add_Action (Table.States (450), 76, 126);
- Add_Action (Table.States (450), 79, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (450), 87, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (450), 94, 127);
+ Add_Goto (Table.States (447), 322, 146);
+ Add_Goto (Table.States (447), 331, 147);
+ Table.States (447).Kernel := To_Vector ((0 => (167, 80, 1, True)));
+ Table.States (447).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
+ Table.States (447).Minimal_Complete_Actions_Recursive := True;
+ Table.States (448).Action_List.Set_Capacity (18);
+ Add_Action (Table.States (448), 3, 122);
+ Add_Action (Table.States (448), 35, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (448), 39, 123);
+ Add_Action (Table.States (448), 40, 124);
+ Add_Action (Table.States (448), 41, 125);
+ Add_Action (Table.States (448), 52, 126);
+ Add_Action (Table.States (448), 76, 127);
+ Add_Action (Table.States (448), 77, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (448), 79, 31);
+ Add_Action (Table.States (448), 81, 607);
+ Add_Action (Table.States (448), 84, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (448), 95, 128);
+ Add_Action (Table.States (448), 96, 129);
+ Add_Action (Table.States (448), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (448), 104, 130);
+ Add_Action (Table.States (448), 105, 120);
+ Add_Action (Table.States (448), 106, 34);
+ Add_Action (Table.States (448), 107, 35);
+ Table.States (448).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (448), 118, 131);
+ Add_Goto (Table.States (448), 129, 42);
+ Add_Goto (Table.States (448), 192, 132);
+ Add_Goto (Table.States (448), 193, 608);
+ Add_Goto (Table.States (448), 198, 134);
+ Add_Goto (Table.States (448), 240, 135);
+ Add_Goto (Table.States (448), 259, 136);
+ Add_Goto (Table.States (448), 273, 93);
+ Add_Goto (Table.States (448), 276, 137);
+ Add_Goto (Table.States (448), 283, 138);
+ Add_Goto (Table.States (448), 284, 139);
+ Add_Goto (Table.States (448), 285, 140);
+ Add_Goto (Table.States (448), 286, 141);
+ Add_Goto (Table.States (448), 287, 142);
+ Add_Goto (Table.States (448), 288, 143);
+ Add_Goto (Table.States (448), 294, 98);
+ Add_Goto (Table.States (448), 302, 144);
+ Add_Goto (Table.States (448), 321, 145);
+ Add_Goto (Table.States (448), 322, 146);
+ Add_Goto (Table.States (448), 331, 147);
+ Table.States (448).Kernel := To_Vector (((125, 88, 0, False),
(125, 88, 1, False)));
+ Table.States (448).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (449).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (449), 19, 609);
+ Table.States (449).Kernel := To_Vector ((0 => (118, 74, 2,
False)));
+ Table.States (449).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 19, 609)));
+ Table.States (450).Action_List.Set_Capacity (19);
+ Add_Action (Table.States (450), 3, 122);
+ Add_Action (Table.States (450), 28, 517);
+ Add_Action (Table.States (450), 39, 123);
+ Add_Action (Table.States (450), 40, 262);
+ Add_Action (Table.States (450), 41, 610);
+ Add_Action (Table.States (450), 44, 264);
+ Add_Action (Table.States (450), 52, 126);
+ Add_Action (Table.States (450), 76, 127);
+ Add_Action (Table.States (450), 77, Reduce, (125, 6), 0, null,
null);
+ Add_Action (Table.States (450), 79, 31);
+ Add_Action (Table.States (450), 80, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (450), 84, Reduce, (125, 6), 0, null,
null);
+ Add_Action (Table.States (450), 88, Reduce, (167, 2), 0, null,
null);
Add_Action (Table.States (450), 95, 128);
- Add_Action (Table.States (450), 103, 129);
- Add_Action (Table.States (450), 104, 119);
- Add_Action (Table.States (450), 105, 33);
+ Add_Action (Table.States (450), 96, 129);
+ Add_Action (Table.States (450), 104, 130);
+ Add_Action (Table.States (450), 105, 120);
Add_Action (Table.States (450), 106, 34);
- Table.States (450).Goto_List.Set_Capacity (22);
- Add_Goto (Table.States (450), 117, 130);
- Add_Goto (Table.States (450), 128, 41);
- Add_Goto (Table.States (450), 165, 269);
- Add_Goto (Table.States (450), 166, 608);
- Add_Goto (Table.States (450), 191, 601);
- Add_Goto (Table.States (450), 197, 133);
- Add_Goto (Table.States (450), 239, 274);
- Add_Goto (Table.States (450), 258, 135);
- Add_Goto (Table.States (450), 272, 92);
- Add_Goto (Table.States (450), 275, 136);
- Add_Goto (Table.States (450), 277, 276);
- Add_Goto (Table.States (450), 282, 137);
+ Add_Action (Table.States (450), 107, 265);
+ Table.States (450).Goto_List.Set_Capacity (24);
+ Add_Goto (Table.States (450), 118, 131);
+ Add_Goto (Table.States (450), 125, 266);
+ Add_Goto (Table.States (450), 126, 611);
+ Add_Goto (Table.States (450), 129, 42);
+ Add_Goto (Table.States (450), 166, 270);
+ Add_Goto (Table.States (450), 167, 271);
+ Add_Goto (Table.States (450), 192, 409);
+ Add_Goto (Table.States (450), 198, 134);
+ Add_Goto (Table.States (450), 240, 275);
+ Add_Goto (Table.States (450), 259, 136);
+ Add_Goto (Table.States (450), 273, 93);
+ Add_Goto (Table.States (450), 276, 137);
+ Add_Goto (Table.States (450), 278, 277);
Add_Goto (Table.States (450), 283, 138);
Add_Goto (Table.States (450), 284, 139);
Add_Goto (Table.States (450), 285, 140);
Add_Goto (Table.States (450), 286, 141);
Add_Goto (Table.States (450), 287, 142);
- Add_Goto (Table.States (450), 293, 97);
- Add_Goto (Table.States (450), 301, 277);
- Add_Goto (Table.States (450), 320, 144);
+ Add_Goto (Table.States (450), 288, 143);
+ Add_Goto (Table.States (450), 294, 98);
+ Add_Goto (Table.States (450), 302, 278);
Add_Goto (Table.States (450), 321, 145);
- Add_Goto (Table.States (450), 330, 146);
- Table.States (450).Kernel := To_Vector ((0 => (140, 72, 1,
False)));
- Table.States (450).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 166, 0)));
- Table.States (451).Action_List.Set_Capacity (2);
- Add_Action (Table.States (451), (24, 72), (141, 1), 1, null, null);
- Table.States (451).Kernel := To_Vector ((0 => (141, 140, 0,
False)));
- Table.States (451).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 141, 1)));
- Table.States (452).Action_List.Set_Capacity (2);
- Add_Action (Table.States (452), 24, 609);
- Add_Action (Table.States (452), 72, 450);
- Table.States (452).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (452), 140, 610);
- Table.States (452).Kernel := To_Vector (((139, 141, 3, False),
(141, 141, 2, True)));
- Table.States (452).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 609)));
- Table.States (453).Action_List.Set_Capacity (35);
- Add_Action (Table.States (453), (10, 20, 21, 22, 23, 33, 35, 37,
38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
- 78, 79, 82, 83, 85, 86, 87, 88, 89, 91, 92, 94, 95, 96, 97, 98,
99), (197, 0), 3, null, null);
- Table.States (453).Kernel := To_Vector ((0 => (197, 258, 0,
False)));
- Table.States (453).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 197, 3)));
- Table.States (454).Action_List.Set_Capacity (17);
- Add_Action (Table.States (454), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 79, 83, 87, 96), (282,
+ Add_Goto (Table.States (450), 322, 146);
+ Add_Goto (Table.States (450), 331, 147);
+ Table.States (450).Kernel := To_Vector (((118, 74, 3, False),
(118, 74, 1, False)));
+ Table.States (450).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 126, 0)));
+ Table.States (451).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (451), 7, 417);
+ Add_Action (Table.States (451), 19, 418);
+ Add_Action (Table.States (451), 20, 419);
+ Add_Action (Table.States (451), 38, 420);
+ Add_Action (Table.States (451), 53, 612);
+ Add_Action (Table.States (451), 76, 127);
+ Add_Action (Table.States (451), 105, 421);
+ Table.States (451).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (451), 118, 422);
+ Add_Goto (Table.States (451), 130, 423);
+ Table.States (451).Kernel := To_Vector (((129, 323, 1, True),
(273, 323, 2, True), (278, 323, 3, False),
+ (278, 323, 1, False)));
+ Table.States (451).Minimal_Complete_Actions := To_Vector (((Shift,
105, 421), (Shift, 53, 612)));
+ Table.States (451).Minimal_Complete_Actions_Recursive := True;
+ Table.States (452).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (452), 3, 122);
+ Add_Action (Table.States (452), 39, 123);
+ Add_Action (Table.States (452), 40, 124);
+ Add_Action (Table.States (452), 41, 125);
+ Add_Action (Table.States (452), 76, 127);
+ Add_Action (Table.States (452), 79, 31);
+ Add_Action (Table.States (452), 95, 128);
+ Add_Action (Table.States (452), 96, 129);
+ Add_Action (Table.States (452), 104, 130);
+ Add_Action (Table.States (452), 105, 120);
+ Add_Action (Table.States (452), 106, 34);
+ Add_Action (Table.States (452), 107, 35);
+ Table.States (452).Goto_List.Set_Capacity (11);
+ Add_Goto (Table.States (452), 118, 131);
+ Add_Goto (Table.States (452), 129, 42);
+ Add_Goto (Table.States (452), 198, 134);
+ Add_Goto (Table.States (452), 240, 135);
+ Add_Goto (Table.States (452), 259, 136);
+ Add_Goto (Table.States (452), 273, 93);
+ Add_Goto (Table.States (452), 294, 98);
+ Add_Goto (Table.States (452), 302, 613);
+ Add_Goto (Table.States (452), 321, 145);
+ Add_Goto (Table.States (452), 322, 146);
+ Add_Goto (Table.States (452), 331, 147);
+ Table.States (452).Kernel := To_Vector ((0 => (278, 86, 1,
False)));
+ Table.States (452).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
+ Table.States (453).Action_List.Set_Capacity (16);
+ Add_Action (Table.States (453), 3, 122);
+ Add_Action (Table.States (453), 39, 123);
+ Add_Action (Table.States (453), 40, 262);
+ Add_Action (Table.States (453), 41, 125);
+ Add_Action (Table.States (453), 44, 264);
+ Add_Action (Table.States (453), 52, 126);
+ Add_Action (Table.States (453), 76, 127);
+ Add_Action (Table.States (453), 79, 31);
+ Add_Action (Table.States (453), 80, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (453), 88, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (453), 95, 128);
+ Add_Action (Table.States (453), 96, 129);
+ Add_Action (Table.States (453), 104, 130);
+ Add_Action (Table.States (453), 105, 120);
+ Add_Action (Table.States (453), 106, 34);
+ Add_Action (Table.States (453), 107, 35);
+ Table.States (453).Goto_List.Set_Capacity (22);
+ Add_Goto (Table.States (453), 118, 131);
+ Add_Goto (Table.States (453), 129, 42);
+ Add_Goto (Table.States (453), 166, 270);
+ Add_Goto (Table.States (453), 167, 614);
+ Add_Goto (Table.States (453), 192, 606);
+ Add_Goto (Table.States (453), 198, 134);
+ Add_Goto (Table.States (453), 240, 275);
+ Add_Goto (Table.States (453), 259, 136);
+ Add_Goto (Table.States (453), 273, 93);
+ Add_Goto (Table.States (453), 276, 137);
+ Add_Goto (Table.States (453), 278, 277);
+ Add_Goto (Table.States (453), 283, 138);
+ Add_Goto (Table.States (453), 284, 139);
+ Add_Goto (Table.States (453), 285, 140);
+ Add_Goto (Table.States (453), 286, 141);
+ Add_Goto (Table.States (453), 287, 142);
+ Add_Goto (Table.States (453), 288, 143);
+ Add_Goto (Table.States (453), 294, 98);
+ Add_Goto (Table.States (453), 302, 278);
+ Add_Goto (Table.States (453), 321, 145);
+ Add_Goto (Table.States (453), 322, 146);
+ Add_Goto (Table.States (453), 331, 147);
+ Table.States (453).Kernel := To_Vector ((0 => (141, 72, 1,
False)));
+ Table.States (453).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 167, 0)));
+ Table.States (454).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (454), (24, 72), (142, 1), 1, null, null);
+ Table.States (454).Kernel := To_Vector ((0 => (142, 141, 0,
False)));
+ Table.States (454).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 142, 1)));
+ Table.States (455).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (455), 24, 615);
+ Add_Action (Table.States (455), 72, 453);
+ Table.States (455).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (455), 141, 616);
+ Table.States (455).Kernel := To_Vector (((140, 142, 3, False),
(142, 142, 2, True)));
+ Table.States (455).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 615)));
+ Table.States (456).Action_List.Set_Capacity (35);
+ Add_Action (Table.States (456), (10, 20, 21, 22, 23, 33, 35, 37,
38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
+ 78, 80, 83, 84, 86, 87, 88, 89, 90, 92, 93, 95, 96, 97, 98, 99,
100), (198, 0), 3, null, null);
+ Table.States (456).Kernel := To_Vector ((0 => (198, 259, 0,
False)));
+ Table.States (456).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 198, 3)));
+ Table.States (457).Action_List.Set_Capacity (17);
+ Add_Action (Table.States (457), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 80, 84, 88, 97), (283,
0), 3, null, null);
- Table.States (454).Kernel := To_Vector ((0 => (282, 287, 0,
True)));
- Table.States (454).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 282, 3)));
- Table.States (454).Minimal_Complete_Actions_Recursive := True;
- Table.States (455).Action_List.Set_Capacity (12);
- Add_Action (Table.States (455), 3, 121);
- Add_Action (Table.States (455), 39, 122);
- Add_Action (Table.States (455), 40, 123);
- Add_Action (Table.States (455), 41, 124);
- Add_Action (Table.States (455), 52, 125);
- Add_Action (Table.States (455), 76, 126);
- Add_Action (Table.States (455), 94, 127);
- Add_Action (Table.States (455), 95, 128);
- Add_Action (Table.States (455), 103, 129);
- Add_Action (Table.States (455), 104, 119);
- Add_Action (Table.States (455), 105, 33);
- Add_Action (Table.States (455), 106, 34);
- Table.States (455).Goto_List.Set_Capacity (13);
- Add_Goto (Table.States (455), 117, 130);
- Add_Goto (Table.States (455), 128, 41);
- Add_Goto (Table.States (455), 197, 133);
- Add_Goto (Table.States (455), 239, 134);
- Add_Goto (Table.States (455), 258, 135);
- Add_Goto (Table.States (455), 272, 92);
- Add_Goto (Table.States (455), 275, 136);
- Add_Goto (Table.States (455), 287, 611);
- Add_Goto (Table.States (455), 293, 97);
- Add_Goto (Table.States (455), 301, 143);
- Add_Goto (Table.States (455), 320, 144);
- Add_Goto (Table.States (455), 321, 145);
- Add_Goto (Table.States (455), 330, 146);
- Table.States (455).Kernel := To_Vector ((0 => (283, 68, 1, True)));
- Table.States (455).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
- Table.States (455).Minimal_Complete_Actions_Recursive := True;
- Table.States (456).Action_List.Set_Capacity (17);
- Add_Action (Table.States (456), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 79, 83, 87, 96), (284,
- 0), 3, null, null);
- Table.States (456).Kernel := To_Vector ((0 => (284, 287, 0,
True)));
- Table.States (456).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 284, 3)));
- Table.States (456).Minimal_Complete_Actions_Recursive := True;
- Table.States (457).Action_List.Set_Capacity (12);
- Add_Action (Table.States (457), 3, 121);
- Add_Action (Table.States (457), 39, 122);
- Add_Action (Table.States (457), 40, 123);
- Add_Action (Table.States (457), 41, 124);
- Add_Action (Table.States (457), 52, 125);
- Add_Action (Table.States (457), 76, 126);
- Add_Action (Table.States (457), 94, 127);
- Add_Action (Table.States (457), 95, 128);
- Add_Action (Table.States (457), 103, 129);
- Add_Action (Table.States (457), 104, 119);
- Add_Action (Table.States (457), 105, 33);
- Add_Action (Table.States (457), 106, 34);
- Table.States (457).Goto_List.Set_Capacity (13);
- Add_Goto (Table.States (457), 117, 130);
- Add_Goto (Table.States (457), 128, 41);
- Add_Goto (Table.States (457), 197, 133);
- Add_Goto (Table.States (457), 239, 134);
- Add_Goto (Table.States (457), 258, 135);
- Add_Goto (Table.States (457), 272, 92);
- Add_Goto (Table.States (457), 275, 136);
- Add_Goto (Table.States (457), 287, 612);
- Add_Goto (Table.States (457), 293, 97);
- Add_Goto (Table.States (457), 301, 143);
- Add_Goto (Table.States (457), 320, 144);
- Add_Goto (Table.States (457), 321, 145);
- Add_Goto (Table.States (457), 330, 146);
- Table.States (457).Kernel := To_Vector ((0 => (285, 22, 1, True)));
- Table.States (457).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
+ Table.States (457).Kernel := To_Vector ((0 => (283, 288, 0,
True)));
+ Table.States (457).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 283, 3)));
Table.States (457).Minimal_Complete_Actions_Recursive := True;
- Table.States (458).Action_List.Set_Capacity (17);
- Add_Action (Table.States (458), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 79, 83, 87, 96), (286,
- 0), 3, null, null);
- Table.States (458).Kernel := To_Vector ((0 => (286, 287, 0,
True)));
- Table.States (458).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 286, 3)));
+ Table.States (458).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (458), 3, 122);
+ Add_Action (Table.States (458), 39, 123);
+ Add_Action (Table.States (458), 40, 124);
+ Add_Action (Table.States (458), 41, 125);
+ Add_Action (Table.States (458), 52, 126);
+ Add_Action (Table.States (458), 76, 127);
+ Add_Action (Table.States (458), 79, 31);
+ Add_Action (Table.States (458), 95, 128);
+ Add_Action (Table.States (458), 96, 129);
+ Add_Action (Table.States (458), 104, 130);
+ Add_Action (Table.States (458), 105, 120);
+ Add_Action (Table.States (458), 106, 34);
+ Add_Action (Table.States (458), 107, 35);
+ Table.States (458).Goto_List.Set_Capacity (13);
+ Add_Goto (Table.States (458), 118, 131);
+ Add_Goto (Table.States (458), 129, 42);
+ Add_Goto (Table.States (458), 198, 134);
+ Add_Goto (Table.States (458), 240, 135);
+ Add_Goto (Table.States (458), 259, 136);
+ Add_Goto (Table.States (458), 273, 93);
+ Add_Goto (Table.States (458), 276, 137);
+ Add_Goto (Table.States (458), 288, 617);
+ Add_Goto (Table.States (458), 294, 98);
+ Add_Goto (Table.States (458), 302, 144);
+ Add_Goto (Table.States (458), 321, 145);
+ Add_Goto (Table.States (458), 322, 146);
+ Add_Goto (Table.States (458), 331, 147);
+ Table.States (458).Kernel := To_Vector ((0 => (284, 68, 1, True)));
+ Table.States (458).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
Table.States (458).Minimal_Complete_Actions_Recursive := True;
- Table.States (459).Action_List.Set_Capacity (12);
- Add_Action (Table.States (459), 3, 121);
- Add_Action (Table.States (459), 39, 122);
- Add_Action (Table.States (459), 40, 123);
- Add_Action (Table.States (459), 41, 124);
- Add_Action (Table.States (459), 52, 125);
- Add_Action (Table.States (459), 76, 126);
- Add_Action (Table.States (459), 94, 127);
- Add_Action (Table.States (459), 95, 128);
- Add_Action (Table.States (459), 103, 129);
- Add_Action (Table.States (459), 104, 119);
- Add_Action (Table.States (459), 105, 33);
- Add_Action (Table.States (459), 106, 34);
- Table.States (459).Goto_List.Set_Capacity (13);
- Add_Goto (Table.States (459), 117, 130);
- Add_Goto (Table.States (459), 128, 41);
- Add_Goto (Table.States (459), 197, 133);
- Add_Goto (Table.States (459), 239, 134);
- Add_Goto (Table.States (459), 258, 135);
- Add_Goto (Table.States (459), 272, 92);
- Add_Goto (Table.States (459), 275, 136);
- Add_Goto (Table.States (459), 287, 613);
- Add_Goto (Table.States (459), 293, 97);
- Add_Goto (Table.States (459), 301, 143);
- Add_Goto (Table.States (459), 320, 144);
- Add_Goto (Table.States (459), 321, 145);
- Add_Goto (Table.States (459), 330, 146);
- Table.States (459).Kernel := To_Vector ((0 => (283, 68, 1, True)));
- Table.States (459).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
+ Table.States (459).Action_List.Set_Capacity (17);
+ Add_Action (Table.States (459), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 80, 84, 88, 97), (285,
+ 0), 3, null, null);
+ Table.States (459).Kernel := To_Vector ((0 => (285, 288, 0,
True)));
+ Table.States (459).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 285, 3)));
Table.States (459).Minimal_Complete_Actions_Recursive := True;
- Table.States (460).Action_List.Set_Capacity (17);
- Add_Action (Table.States (460), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 79, 83, 87, 96), (282,
- 1), 3, null, null);
- Table.States (460).Kernel := To_Vector ((0 => (282, 287, 0,
True)));
- Table.States (460).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 282, 3)));
+ Table.States (460).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (460), 3, 122);
+ Add_Action (Table.States (460), 39, 123);
+ Add_Action (Table.States (460), 40, 124);
+ Add_Action (Table.States (460), 41, 125);
+ Add_Action (Table.States (460), 52, 126);
+ Add_Action (Table.States (460), 76, 127);
+ Add_Action (Table.States (460), 79, 31);
+ Add_Action (Table.States (460), 95, 128);
+ Add_Action (Table.States (460), 96, 129);
+ Add_Action (Table.States (460), 104, 130);
+ Add_Action (Table.States (460), 105, 120);
+ Add_Action (Table.States (460), 106, 34);
+ Add_Action (Table.States (460), 107, 35);
+ Table.States (460).Goto_List.Set_Capacity (13);
+ Add_Goto (Table.States (460), 118, 131);
+ Add_Goto (Table.States (460), 129, 42);
+ Add_Goto (Table.States (460), 198, 134);
+ Add_Goto (Table.States (460), 240, 135);
+ Add_Goto (Table.States (460), 259, 136);
+ Add_Goto (Table.States (460), 273, 93);
+ Add_Goto (Table.States (460), 276, 137);
+ Add_Goto (Table.States (460), 288, 618);
+ Add_Goto (Table.States (460), 294, 98);
+ Add_Goto (Table.States (460), 302, 144);
+ Add_Goto (Table.States (460), 321, 145);
+ Add_Goto (Table.States (460), 322, 146);
+ Add_Goto (Table.States (460), 331, 147);
+ Table.States (460).Kernel := To_Vector ((0 => (286, 22, 1, True)));
+ Table.States (460).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
Table.States (460).Minimal_Complete_Actions_Recursive := True;
- Table.States (461).Action_List.Set_Capacity (12);
- Add_Action (Table.States (461), 3, 121);
- Add_Action (Table.States (461), 39, 122);
- Add_Action (Table.States (461), 40, 123);
- Add_Action (Table.States (461), 41, 124);
- Add_Action (Table.States (461), 52, 125);
- Add_Action (Table.States (461), 76, 126);
- Add_Action (Table.States (461), 94, 127);
- Add_Action (Table.States (461), 95, 128);
- Add_Action (Table.States (461), 103, 129);
- Add_Action (Table.States (461), 104, 119);
- Add_Action (Table.States (461), 105, 33);
- Add_Action (Table.States (461), 106, 34);
- Table.States (461).Goto_List.Set_Capacity (13);
- Add_Goto (Table.States (461), 117, 130);
- Add_Goto (Table.States (461), 128, 41);
- Add_Goto (Table.States (461), 197, 133);
- Add_Goto (Table.States (461), 239, 134);
- Add_Goto (Table.States (461), 258, 135);
- Add_Goto (Table.States (461), 272, 92);
- Add_Goto (Table.States (461), 275, 136);
- Add_Goto (Table.States (461), 287, 614);
- Add_Goto (Table.States (461), 293, 97);
- Add_Goto (Table.States (461), 301, 143);
- Add_Goto (Table.States (461), 320, 144);
- Add_Goto (Table.States (461), 321, 145);
- Add_Goto (Table.States (461), 330, 146);
- Table.States (461).Kernel := To_Vector ((0 => (285, 22, 1, True)));
- Table.States (461).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
+ Table.States (461).Action_List.Set_Capacity (17);
+ Add_Action (Table.States (461), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 80, 84, 88, 97), (287,
+ 0), 3, null, null);
+ Table.States (461).Kernel := To_Vector ((0 => (287, 288, 0,
True)));
+ Table.States (461).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 287, 3)));
Table.States (461).Minimal_Complete_Actions_Recursive := True;
- Table.States (462).Action_List.Set_Capacity (17);
- Add_Action (Table.States (462), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 79, 83, 87, 96), (284,
- 1), 3, null, null);
- Table.States (462).Kernel := To_Vector ((0 => (284, 287, 0,
True)));
- Table.States (462).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 284, 3)));
+ Table.States (462).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (462), 3, 122);
+ Add_Action (Table.States (462), 39, 123);
+ Add_Action (Table.States (462), 40, 124);
+ Add_Action (Table.States (462), 41, 125);
+ Add_Action (Table.States (462), 52, 126);
+ Add_Action (Table.States (462), 76, 127);
+ Add_Action (Table.States (462), 79, 31);
+ Add_Action (Table.States (462), 95, 128);
+ Add_Action (Table.States (462), 96, 129);
+ Add_Action (Table.States (462), 104, 130);
+ Add_Action (Table.States (462), 105, 120);
+ Add_Action (Table.States (462), 106, 34);
+ Add_Action (Table.States (462), 107, 35);
+ Table.States (462).Goto_List.Set_Capacity (13);
+ Add_Goto (Table.States (462), 118, 131);
+ Add_Goto (Table.States (462), 129, 42);
+ Add_Goto (Table.States (462), 198, 134);
+ Add_Goto (Table.States (462), 240, 135);
+ Add_Goto (Table.States (462), 259, 136);
+ Add_Goto (Table.States (462), 273, 93);
+ Add_Goto (Table.States (462), 276, 137);
+ Add_Goto (Table.States (462), 288, 619);
+ Add_Goto (Table.States (462), 294, 98);
+ Add_Goto (Table.States (462), 302, 144);
+ Add_Goto (Table.States (462), 321, 145);
+ Add_Goto (Table.States (462), 322, 146);
+ Add_Goto (Table.States (462), 331, 147);
+ Table.States (462).Kernel := To_Vector ((0 => (284, 68, 1, True)));
+ Table.States (462).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
Table.States (462).Minimal_Complete_Actions_Recursive := True;
Table.States (463).Action_List.Set_Capacity (17);
- Add_Action (Table.States (463), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 79, 83, 87, 96), (286,
+ Add_Action (Table.States (463), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 80, 84, 88, 97), (283,
1), 3, null, null);
- Table.States (463).Kernel := To_Vector ((0 => (286, 287, 0,
True)));
- Table.States (463).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 286, 3)));
+ Table.States (463).Kernel := To_Vector ((0 => (283, 288, 0,
True)));
+ Table.States (463).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 283, 3)));
Table.States (463).Minimal_Complete_Actions_Recursive := True;
- Table.States (464).Action_List.Set_Capacity (17);
- Add_Action (Table.States (464), 10, Reduce, (287, 1), 3, null,
null);
- Add_Action (Table.States (464), 20, Reduce, (287, 1), 3, null,
null);
- Add_Action (Table.States (464), 21, Reduce, (287, 1), 3, null,
null);
- Add_Action (Table.States (464), 22, Reduce, (287, 1), 3, null,
null);
- Add_Action (Table.States (464), 23, Reduce, (287, 1), 3, null,
null);
- Add_Action (Table.States (464), 35, Reduce, (287, 1), 3, null,
null);
- Add_Action (Table.States (464), 37, Reduce, (287, 1), 3, null,
null);
- Add_Action (Table.States (464), 43, Reduce, (287, 1), 3, null,
null);
- Add_Action (Table.States (464), 53, Reduce, (287, 1), 3, null,
null);
- Add_Action (Table.States (464), 68, Reduce, (287, 1), 3, null,
null);
- Add_Action (Table.States (464), 74, Reduce, (287, 1), 3, null,
null);
- Add_Action (Table.States (464), 75, Reduce, (287, 1), 3, null,
null);
- Add_Action (Table.States (464), 77, Reduce, (287, 1), 3, null,
null);
- Add_Action (Table.States (464), 79, 615);
- Add_Conflict (Table.States (464), 79, (287, 1), 3, null, null);
- Add_Action (Table.States (464), 83, Reduce, (287, 1), 3, null,
null);
- Add_Action (Table.States (464), 87, Reduce, (287, 1), 3, null,
null);
- Add_Action (Table.States (464), 96, Reduce, (287, 1), 3, null,
null);
- Table.States (464).Kernel := To_Vector (((233, 233, 2, True),
(287, 233, 0, False)));
- Table.States (464).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 287, 3)));
+ Table.States (464).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (464), 3, 122);
+ Add_Action (Table.States (464), 39, 123);
+ Add_Action (Table.States (464), 40, 124);
+ Add_Action (Table.States (464), 41, 125);
+ Add_Action (Table.States (464), 52, 126);
+ Add_Action (Table.States (464), 76, 127);
+ Add_Action (Table.States (464), 79, 31);
+ Add_Action (Table.States (464), 95, 128);
+ Add_Action (Table.States (464), 96, 129);
+ Add_Action (Table.States (464), 104, 130);
+ Add_Action (Table.States (464), 105, 120);
+ Add_Action (Table.States (464), 106, 34);
+ Add_Action (Table.States (464), 107, 35);
+ Table.States (464).Goto_List.Set_Capacity (13);
+ Add_Goto (Table.States (464), 118, 131);
+ Add_Goto (Table.States (464), 129, 42);
+ Add_Goto (Table.States (464), 198, 134);
+ Add_Goto (Table.States (464), 240, 135);
+ Add_Goto (Table.States (464), 259, 136);
+ Add_Goto (Table.States (464), 273, 93);
+ Add_Goto (Table.States (464), 276, 137);
+ Add_Goto (Table.States (464), 288, 620);
+ Add_Goto (Table.States (464), 294, 98);
+ Add_Goto (Table.States (464), 302, 144);
+ Add_Goto (Table.States (464), 321, 145);
+ Add_Goto (Table.States (464), 322, 146);
+ Add_Goto (Table.States (464), 331, 147);
+ Table.States (464).Kernel := To_Vector ((0 => (286, 22, 1, True)));
+ Table.States (464).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
+ Table.States (464).Minimal_Complete_Actions_Recursive := True;
Table.States (465).Action_List.Set_Capacity (17);
- Add_Action (Table.States (465), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 79, 83, 87, 96), (233,
- 1), 1, null, null);
- Table.States (465).Kernel := To_Vector ((0 => (233, 234, 0,
False)));
- Table.States (465).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 233, 1)));
+ Add_Action (Table.States (465), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 80, 84, 88, 97), (285,
+ 1), 3, null, null);
+ Table.States (465).Kernel := To_Vector ((0 => (285, 288, 0,
True)));
+ Table.States (465).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 285, 3)));
+ Table.States (465).Minimal_Complete_Actions_Recursive := True;
Table.States (466).Action_List.Set_Capacity (17);
- Add_Action (Table.States (466), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 79, 83, 87, 96), (234,
+ Add_Action (Table.States (466), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 80, 84, 88, 97), (287,
+ 1), 3, null, null);
+ Table.States (466).Kernel := To_Vector ((0 => (287, 288, 0,
True)));
+ Table.States (466).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 287, 3)));
+ Table.States (466).Minimal_Complete_Actions_Recursive := True;
+ Table.States (467).Action_List.Set_Capacity (17);
+ Add_Action (Table.States (467), 10, Reduce, (288, 1), 3, null,
null);
+ Add_Action (Table.States (467), 20, Reduce, (288, 1), 3, null,
null);
+ Add_Action (Table.States (467), 21, Reduce, (288, 1), 3, null,
null);
+ Add_Action (Table.States (467), 22, Reduce, (288, 1), 3, null,
null);
+ Add_Action (Table.States (467), 23, Reduce, (288, 1), 3, null,
null);
+ Add_Action (Table.States (467), 35, Reduce, (288, 1), 3, null,
null);
+ Add_Action (Table.States (467), 37, Reduce, (288, 1), 3, null,
null);
+ Add_Action (Table.States (467), 43, Reduce, (288, 1), 3, null,
null);
+ Add_Action (Table.States (467), 53, Reduce, (288, 1), 3, null,
null);
+ Add_Action (Table.States (467), 68, Reduce, (288, 1), 3, null,
null);
+ Add_Action (Table.States (467), 74, Reduce, (288, 1), 3, null,
null);
+ Add_Action (Table.States (467), 75, Reduce, (288, 1), 3, null,
null);
+ Add_Action (Table.States (467), 77, Reduce, (288, 1), 3, null,
null);
+ Add_Action (Table.States (467), 80, 621);
+ Add_Conflict (Table.States (467), 80, (288, 1), 3, null, null);
+ Add_Action (Table.States (467), 84, Reduce, (288, 1), 3, null,
null);
+ Add_Action (Table.States (467), 88, Reduce, (288, 1), 3, null,
null);
+ Add_Action (Table.States (467), 97, Reduce, (288, 1), 3, null,
null);
+ Table.States (467).Kernel := To_Vector (((234, 234, 2, True),
(288, 234, 0, False)));
+ Table.States (467).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 288, 3)));
+ Table.States (468).Action_List.Set_Capacity (17);
+ Add_Action (Table.States (468), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 80, 84, 88, 97), (234,
1), 1, null, null);
- Table.States (466).Kernel := To_Vector ((0 => (234, 277, 0,
False)));
- Table.States (466).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 234, 1)));
- Table.States (467).Action_List.Set_Capacity (18);
- Add_Action (Table.States (467), 10, Reduce, (234, 0), 1, null,
null);
- Add_Action (Table.States (467), 20, Reduce, (234, 0), 1, null,
null);
- Add_Action (Table.States (467), 21, Reduce, (234, 0), 1, null,
null);
- Add_Action (Table.States (467), 22, Reduce, (234, 0), 1, null,
null);
- Add_Action (Table.States (467), 23, Reduce, (234, 0), 1, null,
null);
- Add_Action (Table.States (467), 35, Reduce, (234, 0), 1, null,
null);
- Add_Action (Table.States (467), 37, Reduce, (234, 0), 1, null,
null);
- Add_Action (Table.States (467), 43, Reduce, (234, 0), 1, null,
null);
- Add_Action (Table.States (467), 53, Reduce, (234, 0), 1, null,
null);
- Add_Action (Table.States (467), 68, Reduce, (234, 0), 1, null,
null);
- Add_Action (Table.States (467), 74, Reduce, (234, 0), 1, null,
null);
- Add_Action (Table.States (467), 75, Reduce, (234, 0), 1, null,
null);
- Add_Action (Table.States (467), 77, Reduce, (234, 0), 1, null,
null);
- Add_Action (Table.States (467), 79, Reduce, (234, 0), 1, null,
null);
- Add_Action (Table.States (467), 83, Reduce, (234, 0), 1, null,
null);
- Add_Action (Table.States (467), 85, 449);
- Add_Action (Table.States (467), 87, Reduce, (234, 0), 1, null,
null);
- Add_Action (Table.States (467), 96, Reduce, (234, 0), 1, null,
null);
- Table.States (467).Kernel := To_Vector (((234, 301, 0, False),
(277, 301, 2, False)));
- Table.States (467).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 234, 1)));
- Table.States (468).Action_List.Set_Capacity (11);
- Add_Action (Table.States (468), 3, 121);
- Add_Action (Table.States (468), 39, 122);
- Add_Action (Table.States (468), 40, 123);
- Add_Action (Table.States (468), 41, 124);
- Add_Action (Table.States (468), 76, 126);
- Add_Action (Table.States (468), 94, 127);
- Add_Action (Table.States (468), 95, 128);
- Add_Action (Table.States (468), 103, 129);
- Add_Action (Table.States (468), 104, 119);
- Add_Action (Table.States (468), 105, 33);
- Add_Action (Table.States (468), 106, 34);
- Table.States (468).Goto_List.Set_Capacity (14);
- Add_Goto (Table.States (468), 117, 130);
- Add_Goto (Table.States (468), 128, 41);
- Add_Goto (Table.States (468), 197, 133);
- Add_Goto (Table.States (468), 233, 616);
- Add_Goto (Table.States (468), 234, 465);
- Add_Goto (Table.States (468), 239, 274);
- Add_Goto (Table.States (468), 258, 135);
- Add_Goto (Table.States (468), 272, 92);
- Add_Goto (Table.States (468), 277, 466);
- Add_Goto (Table.States (468), 293, 97);
- Add_Goto (Table.States (468), 301, 467);
- Add_Goto (Table.States (468), 320, 144);
- Add_Goto (Table.States (468), 321, 145);
- Add_Goto (Table.States (468), 330, 146);
- Table.States (468).Kernel := To_Vector ((0 => (287, 33, 1,
False)));
- Table.States (468).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
+ Table.States (468).Kernel := To_Vector ((0 => (234, 235, 0,
False)));
+ Table.States (468).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 234, 1)));
Table.States (469).Action_List.Set_Capacity (17);
- Add_Action (Table.States (469), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 79, 83, 87, 96), (287,
+ Add_Action (Table.States (469), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 80, 84, 88, 97), (235,
+ 1), 1, null, null);
+ Table.States (469).Kernel := To_Vector ((0 => (235, 278, 0,
False)));
+ Table.States (469).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 235, 1)));
+ Table.States (470).Action_List.Set_Capacity (18);
+ Add_Action (Table.States (470), 10, Reduce, (235, 0), 1, null,
null);
+ Add_Action (Table.States (470), 20, Reduce, (235, 0), 1, null,
null);
+ Add_Action (Table.States (470), 21, Reduce, (235, 0), 1, null,
null);
+ Add_Action (Table.States (470), 22, Reduce, (235, 0), 1, null,
null);
+ Add_Action (Table.States (470), 23, Reduce, (235, 0), 1, null,
null);
+ Add_Action (Table.States (470), 35, Reduce, (235, 0), 1, null,
null);
+ Add_Action (Table.States (470), 37, Reduce, (235, 0), 1, null,
null);
+ Add_Action (Table.States (470), 43, Reduce, (235, 0), 1, null,
null);
+ Add_Action (Table.States (470), 53, Reduce, (235, 0), 1, null,
null);
+ Add_Action (Table.States (470), 68, Reduce, (235, 0), 1, null,
null);
+ Add_Action (Table.States (470), 74, Reduce, (235, 0), 1, null,
null);
+ Add_Action (Table.States (470), 75, Reduce, (235, 0), 1, null,
null);
+ Add_Action (Table.States (470), 77, Reduce, (235, 0), 1, null,
null);
+ Add_Action (Table.States (470), 80, Reduce, (235, 0), 1, null,
null);
+ Add_Action (Table.States (470), 84, Reduce, (235, 0), 1, null,
null);
+ Add_Action (Table.States (470), 86, 452);
+ Add_Action (Table.States (470), 88, Reduce, (235, 0), 1, null,
null);
+ Add_Action (Table.States (470), 97, Reduce, (235, 0), 1, null,
null);
+ Table.States (470).Kernel := To_Vector (((235, 302, 0, False),
(278, 302, 2, False)));
+ Table.States (470).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 235, 1)));
+ Table.States (471).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (471), 3, 122);
+ Add_Action (Table.States (471), 39, 123);
+ Add_Action (Table.States (471), 40, 124);
+ Add_Action (Table.States (471), 41, 125);
+ Add_Action (Table.States (471), 76, 127);
+ Add_Action (Table.States (471), 79, 31);
+ Add_Action (Table.States (471), 95, 128);
+ Add_Action (Table.States (471), 96, 129);
+ Add_Action (Table.States (471), 104, 130);
+ Add_Action (Table.States (471), 105, 120);
+ Add_Action (Table.States (471), 106, 34);
+ Add_Action (Table.States (471), 107, 35);
+ Table.States (471).Goto_List.Set_Capacity (14);
+ Add_Goto (Table.States (471), 118, 131);
+ Add_Goto (Table.States (471), 129, 42);
+ Add_Goto (Table.States (471), 198, 134);
+ Add_Goto (Table.States (471), 234, 622);
+ Add_Goto (Table.States (471), 235, 468);
+ Add_Goto (Table.States (471), 240, 275);
+ Add_Goto (Table.States (471), 259, 136);
+ Add_Goto (Table.States (471), 273, 93);
+ Add_Goto (Table.States (471), 278, 469);
+ Add_Goto (Table.States (471), 294, 98);
+ Add_Goto (Table.States (471), 302, 470);
+ Add_Goto (Table.States (471), 321, 145);
+ Add_Goto (Table.States (471), 322, 146);
+ Add_Goto (Table.States (471), 331, 147);
+ Table.States (471).Kernel := To_Vector ((0 => (288, 33, 1,
False)));
+ Table.States (471).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
+ Table.States (472).Action_List.Set_Capacity (17);
+ Add_Action (Table.States (472), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 80, 84, 88, 97), (288,
2), 3, null, null);
- Table.States (469).Kernel := To_Vector ((0 => (287, 301, 0,
False)));
- Table.States (469).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 287, 3)));
- Table.States (470).Action_List.Set_Capacity (35);
- Add_Action (Table.States (470), (10, 20, 21, 22, 23, 33, 35, 37,
38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
- 78, 79, 82, 83, 85, 86, 87, 88, 89, 91, 92, 94, 95, 96, 97, 98,
99), (320, 0), 3, null, null);
- Table.States (470).Kernel := To_Vector ((0 => (320, 197, 0,
True)));
- Table.States (470).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 320, 3)));
- Table.States (470).Minimal_Complete_Actions_Recursive := True;
- Table.States (471).Action_List.Set_Capacity (35);
- Add_Action (Table.States (471), 10, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 20, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 21, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 22, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 23, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 33, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 35, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 37, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 38, 297);
- Add_Action (Table.States (471), 40, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 42, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 43, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 53, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 55, 298);
- Add_Action (Table.States (471), 68, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 74, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 75, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 77, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 78, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 79, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 82, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 83, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 85, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 86, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 87, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 88, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 89, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 91, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 92, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 94, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 95, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 96, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 97, 299);
- Add_Action (Table.States (471), 98, Reduce, (321, 0), 3, null,
null);
- Add_Action (Table.States (471), 99, 300);
- Table.States (471).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (471), 237, 301);
- Table.States (471).Kernel := To_Vector (((320, 320, 2, True),
(321, 320, 0, True)));
- Table.States (471).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 321, 3)));
- Table.States (471).Minimal_Complete_Actions_Recursive := True;
- Table.States (472).Action_List.Set_Capacity (46);
- Add_Action (Table.States (472), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (161, 0), 4, delay_statement_0'Access, null);
- Table.States (472).Kernel := To_Vector ((0 => (161, 96, 0,
False)));
- Table.States (472).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 161, 4)));
- Table.States (473).Action_List.Set_Capacity (1);
- Add_Action (Table.States (473), 96, 617);
- Table.States (473).Kernel := To_Vector ((0 => (190, 192, 1,
False)));
- Table.States (473).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 617)));
- Table.States (474).Action_List.Set_Capacity (7);
- Add_Action (Table.States (474), 39, 122);
- Add_Action (Table.States (474), 41, 618);
- Add_Action (Table.States (474), 76, 126);
- Add_Action (Table.States (474), 103, 129);
- Add_Action (Table.States (474), 104, 119);
- Add_Action (Table.States (474), 105, 33);
- Add_Action (Table.States (474), 106, 34);
- Table.States (474).Goto_List.Set_Capacity (6);
- Add_Goto (Table.States (474), 117, 130);
- Add_Goto (Table.States (474), 128, 41);
- Add_Goto (Table.States (474), 239, 134);
- Add_Goto (Table.States (474), 258, 256);
- Add_Goto (Table.States (474), 272, 92);
- Add_Goto (Table.States (474), 293, 97);
- Table.States (474).Kernel := To_Vector (((197, 40, 1, False),
(314, 40, 6, False), (314, 40, 2, False)));
- Table.States (474).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
- Table.States (475).Action_List.Set_Capacity (11);
- Add_Action (Table.States (475), 3, 121);
- Add_Action (Table.States (475), 39, 122);
- Add_Action (Table.States (475), 40, 474);
- Add_Action (Table.States (475), 41, 124);
- Add_Action (Table.States (475), 76, 126);
- Add_Action (Table.States (475), 94, 127);
- Add_Action (Table.States (475), 95, 128);
- Add_Action (Table.States (475), 103, 129);
- Add_Action (Table.States (475), 104, 119);
- Add_Action (Table.States (475), 105, 33);
- Add_Action (Table.States (475), 106, 34);
- Table.States (475).Goto_List.Set_Capacity (14);
- Add_Goto (Table.States (475), 117, 130);
- Add_Goto (Table.States (475), 128, 41);
- Add_Goto (Table.States (475), 167, 619);
- Add_Goto (Table.States (475), 197, 133);
- Add_Goto (Table.States (475), 239, 477);
- Add_Goto (Table.States (475), 258, 135);
- Add_Goto (Table.States (475), 272, 92);
- Add_Goto (Table.States (475), 277, 478);
- Add_Goto (Table.States (475), 293, 97);
- Add_Goto (Table.States (475), 301, 479);
- Add_Goto (Table.States (475), 314, 480);
- Add_Goto (Table.States (475), 320, 144);
- Add_Goto (Table.States (475), 321, 145);
- Add_Goto (Table.States (475), 330, 146);
- Table.States (475).Kernel := To_Vector ((0 => (230, 59, 1,
False)));
- Table.States (475).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (476).Action_List.Set_Capacity (2);
- Add_Action (Table.States (476), (37, 87), (230, 5), 3,
iterator_specification_5'Access, null);
- Table.States (476).Kernel := To_Vector ((0 => (230, 167, 0,
False)));
- Table.States (476).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 230, 3)));
- Table.States (477).Action_List.Set_Capacity (30);
- Add_Action (Table.States (477), 10, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (477), 33, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (477), 37, Reduce, (314, 3), 1,
subtype_indication_3'Access, null);
- Add_Action (Table.States (477), 38, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (477), 40, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (477), 43, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (477), 53, 620);
- Add_Action (Table.States (477), 55, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (477), 75, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (477), 76, 621);
- Add_Action (Table.States (477), 77, Reduce, (258, 3), 1, null,
null);
- Add_Conflict (Table.States (477), 77, (314, 3), 1,
subtype_indication_3'Access, null);
- Add_Action (Table.States (477), 78, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (477), 79, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (477), 83, Reduce, (258, 3), 1, null,
null);
- Add_Conflict (Table.States (477), 83, (314, 3), 1,
subtype_indication_3'Access, null);
- Add_Action (Table.States (477), 84, 237);
- Add_Action (Table.States (477), 85, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (477), 86, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (477), 87, Reduce, (258, 3), 1, null,
null);
- Add_Conflict (Table.States (477), 87, (314, 3), 1,
subtype_indication_3'Access, null);
- Add_Action (Table.States (477), 88, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (477), 89, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (477), 91, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (477), 92, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (477), 94, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (477), 95, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (477), 97, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (477), 98, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (477), 99, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (477), 100, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (477), 101, 239);
- Add_Action (Table.States (477), 102, 240);
- Table.States (477).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (477), 115, 241);
- Add_Goto (Table.States (477), 155, 622);
- Add_Goto (Table.States (477), 224, 623);
- Add_Goto (Table.States (477), 322, 448);
- Table.States (477).Kernel := To_Vector (((128, 239, 2, True),
(239, 239, 5, True), (239, 239, 2, True),
- (258, 239, 0, False), (272, 239, 3, True), (277, 239, 4, False),
(277, 239, 2, False), (293, 239, 2, True),
- (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(314, 239, 4, False), (314, 239, 0, False)));
- Table.States (477).Minimal_Complete_Actions := To_Vector
(((Reduce, 258, 1), (Reduce, 314, 1)));
- Table.States (478).Action_List.Set_Capacity (4);
- Add_Action (Table.States (478), (37, 77, 83, 87), (167, 1), 1,
null, null);
- Table.States (478).Kernel := To_Vector ((0 => (167, 277, 0,
False)));
- Table.States (478).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 167, 1)));
- Table.States (479).Action_List.Set_Capacity (1);
- Add_Action (Table.States (479), 85, 449);
- Table.States (479).Kernel := To_Vector ((0 => (277, 301, 2,
False)));
- Table.States (479).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 85, 449)));
- Table.States (480).Action_List.Set_Capacity (4);
- Add_Action (Table.States (480), (37, 77, 83, 87), (167, 0), 1,
null, null);
- Table.States (480).Kernel := To_Vector ((0 => (167, 314, 0,
False)));
- Table.States (480).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 167, 1)));
- Table.States (481).Action_List.Set_Capacity (3);
- Add_Action (Table.States (481), 104, 119);
- Add_Action (Table.States (481), 105, 33);
- Add_Action (Table.States (481), 106, 34);
- Table.States (481).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (481), 128, 41);
- Add_Goto (Table.States (481), 239, 624);
- Add_Goto (Table.States (481), 272, 92);
- Add_Goto (Table.States (481), 293, 97);
- Table.States (481).Kernel := To_Vector ((0 => (230, 59, 1,
False)));
- Table.States (481).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (482).Action_List.Set_Capacity (6);
- Add_Action (Table.States (482), 37, Reduce, (230, 4), 3, null,
null);
- Add_Action (Table.States (482), 76, 235);
- Add_Action (Table.States (482), 84, 237);
- Add_Action (Table.States (482), 87, Reduce, (230, 4), 3, null,
null);
- Add_Action (Table.States (482), 101, 239);
- Add_Action (Table.States (482), 102, 240);
- Table.States (482).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (482), 115, 241);
- Add_Goto (Table.States (482), 322, 242);
- Table.States (482).Kernel := To_Vector (((128, 239, 2, True),
(230, 239, 0, False), (239, 239, 5, True),
- (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (482).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 230, 3)));
- Table.States (483).Action_List.Set_Capacity (1);
- Add_Action (Table.States (483), 41, 625);
- Table.States (483).Kernel := To_Vector (((314, 40, 6, False),
(314, 40, 2, False)));
- Table.States (483).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 41, 625)));
- Table.States (484).Action_List.Set_Capacity (11);
- Add_Action (Table.States (484), 10, Reduce, (314, 3), 1,
subtype_indication_3'Access, null);
- Add_Action (Table.States (484), 21, Reduce, (314, 3), 1,
subtype_indication_3'Access, null);
- Add_Action (Table.States (484), 42, Reduce, (314, 3), 1,
subtype_indication_3'Access, null);
- Add_Action (Table.States (484), 53, 620);
- Add_Action (Table.States (484), 74, Reduce, (314, 3), 1,
subtype_indication_3'Access, null);
- Add_Action (Table.States (484), 76, 621);
- Add_Action (Table.States (484), 82, Reduce, (314, 3), 1,
subtype_indication_3'Access, null);
- Add_Action (Table.States (484), 84, 237);
- Add_Action (Table.States (484), 96, Reduce, (314, 3), 1,
subtype_indication_3'Access, null);
- Add_Action (Table.States (484), 101, 239);
- Add_Action (Table.States (484), 102, 240);
- Table.States (484).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (484), 115, 241);
- Add_Goto (Table.States (484), 155, 622);
- Add_Goto (Table.States (484), 224, 623);
- Add_Goto (Table.States (484), 322, 242);
- Table.States (484).Kernel := To_Vector (((128, 239, 2, True),
(239, 239, 5, True), (239, 239, 2, True),
- (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (314, 239, 4, False), (314, 239, 0, False)));
- Table.States (484).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 314, 1)));
- Table.States (485).Action_List.Set_Capacity (1);
- Add_Action (Table.States (485), 42, 626);
- Table.States (485).Kernel := To_Vector (((230, 314, 3, False),
(230, 314, 2, False)));
- Table.States (485).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 42, 626)));
- Table.States (486).Action_List.Set_Capacity (1);
- Add_Action (Table.States (486), 96, 627);
- Table.States (486).Kernel := To_Vector ((0 => (121, 192, 1,
False)));
- Table.States (486).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 627)));
- Table.States (487).Action_List.Set_Capacity (13);
- Add_Action (Table.States (487), 3, 121);
- Add_Action (Table.States (487), 39, 122);
- Add_Action (Table.States (487), 40, 123);
- Add_Action (Table.States (487), 41, 124);
- Add_Action (Table.States (487), 52, 125);
- Add_Action (Table.States (487), 76, 126);
- Add_Action (Table.States (487), 94, 127);
- Add_Action (Table.States (487), 95, 128);
- Add_Action (Table.States (487), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (487), 103, 129);
- Add_Action (Table.States (487), 104, 119);
- Add_Action (Table.States (487), 105, 33);
- Add_Action (Table.States (487), 106, 34);
- Table.States (487).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (487), 117, 130);
- Add_Goto (Table.States (487), 128, 41);
- Add_Goto (Table.States (487), 191, 131);
- Add_Goto (Table.States (487), 192, 628);
- Add_Goto (Table.States (487), 197, 133);
- Add_Goto (Table.States (487), 239, 134);
- Add_Goto (Table.States (487), 258, 135);
- Add_Goto (Table.States (487), 272, 92);
- Add_Goto (Table.States (487), 275, 136);
- Add_Goto (Table.States (487), 282, 137);
- Add_Goto (Table.States (487), 283, 138);
- Add_Goto (Table.States (487), 284, 139);
- Add_Goto (Table.States (487), 285, 140);
- Add_Goto (Table.States (487), 286, 141);
- Add_Goto (Table.States (487), 287, 142);
- Add_Goto (Table.States (487), 293, 97);
- Add_Goto (Table.States (487), 301, 143);
- Add_Goto (Table.States (487), 320, 144);
- Add_Goto (Table.States (487), 321, 145);
- Add_Goto (Table.States (487), 330, 146);
- Table.States (487).Kernel := To_Vector ((0 => (127, 12, 1,
False)));
- Table.States (487).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (488).Action_List.Set_Capacity (2);
- Add_Action (Table.States (488), 12, 629);
- Add_Action (Table.States (488), 104, Reduce, (235, 1), 0, null,
null);
- Table.States (488).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (488), 235, 630);
- Table.States (488).Kernel := To_Vector ((0 => (281, 54, 11,
False)));
- Table.States (488).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 235, 0)));
- Table.States (489).Action_List.Set_Capacity (1);
- Add_Action (Table.States (489), 96, 631);
- Table.States (489).Kernel := To_Vector ((0 => (182, 117, 1,
False)));
- Table.States (489).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 631)));
- Table.States (490).Action_List.Set_Capacity (7);
- Add_Action (Table.States (490), (21, 35, 56, 74, 77, 82, 96),
(291, 1), 2, result_profile_1'Access, null);
- Table.States (490).Kernel := To_Vector ((0 => (291, 114, 0,
True)));
- Table.States (490).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 291, 2)));
- Table.States (490).Minimal_Complete_Actions_Recursive := True;
- Table.States (491).Action_List.Set_Capacity (11);
- Add_Action (Table.States (491), 7, 556);
- Add_Action (Table.States (491), 21, Reduce, (240, 1), 0, null,
null);
- Add_Action (Table.States (491), 35, Reduce, (240, 1), 0, null,
null);
- Add_Action (Table.States (491), 56, Reduce, (240, 1), 0, null,
null);
- Add_Action (Table.States (491), 74, Reduce, (240, 1), 0, null,
null);
- Add_Action (Table.States (491), 77, Reduce, (240, 1), 0, null,
null);
- Add_Action (Table.States (491), 82, Reduce, (240, 1), 0, null,
null);
- Add_Action (Table.States (491), 96, Reduce, (240, 1), 0, null,
null);
- Add_Action (Table.States (491), 104, 119);
- Add_Action (Table.States (491), 105, 33);
- Add_Action (Table.States (491), 106, 34);
- Table.States (491).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (491), 128, 41);
- Add_Goto (Table.States (491), 239, 632);
- Add_Goto (Table.States (491), 240, 633);
- Add_Goto (Table.States (491), 272, 92);
- Add_Goto (Table.States (491), 293, 97);
- Table.States (491).Kernel := To_Vector (((114, 241, 2, False),
(114, 241, 3, True), (114, 241, 2, False),
- (291, 241, 0, False)));
- Table.States (491).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 240, 0)));
- Table.States (492).Action_List.Set_Capacity (30);
- Add_Action (Table.States (492), 10, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 33, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 38, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 40, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 43, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 53, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 55, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 75, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 76, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 77, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 78, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 79, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 81, Reduce, (219, 1), 1,
identifier_list_1'Access, null);
- Add_Action (Table.States (492), 83, Reduce, (219, 1), 1,
identifier_list_1'Access, null);
- Add_Conflict (Table.States (492), 83, (239, 5), 1, name_5'Access,
name_5_check'Access);
- Add_Action (Table.States (492), 84, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 85, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 86, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 87, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 88, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 89, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 91, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 92, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 94, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 95, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 97, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 98, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 99, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 100, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 101, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (492), 102, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Table.States (492).Kernel := To_Vector (((219, 104, 0, False),
(239, 104, 0, False)));
- Table.States (492).Minimal_Complete_Actions := To_Vector
(((Reduce, 219, 1), (Reduce, 239, 1)));
+ Table.States (472).Kernel := To_Vector ((0 => (288, 302, 0,
False)));
+ Table.States (472).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 288, 3)));
+ Table.States (473).Action_List.Set_Capacity (35);
+ Add_Action (Table.States (473), (10, 20, 21, 22, 23, 33, 35, 37,
38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
+ 78, 80, 83, 84, 86, 87, 88, 89, 90, 92, 93, 95, 96, 97, 98, 99,
100), (321, 0), 3, null, null);
+ Table.States (473).Kernel := To_Vector ((0 => (321, 198, 0,
True)));
+ Table.States (473).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 321, 3)));
+ Table.States (473).Minimal_Complete_Actions_Recursive := True;
+ Table.States (474).Action_List.Set_Capacity (35);
+ Add_Action (Table.States (474), 10, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 20, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 21, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 22, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 23, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 33, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 35, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 37, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 38, 298);
+ Add_Action (Table.States (474), 40, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 42, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 43, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 53, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 55, 299);
+ Add_Action (Table.States (474), 68, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 74, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 75, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 77, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 78, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 80, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 83, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 84, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 86, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 87, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 88, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 89, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 90, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 92, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 93, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 95, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 96, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 97, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 98, 300);
+ Add_Action (Table.States (474), 99, Reduce, (322, 0), 3, null,
null);
+ Add_Action (Table.States (474), 100, 301);
+ Table.States (474).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (474), 238, 302);
+ Table.States (474).Kernel := To_Vector (((321, 321, 2, True),
(322, 321, 0, True)));
+ Table.States (474).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 322, 3)));
+ Table.States (474).Minimal_Complete_Actions_Recursive := True;
+ Table.States (475).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (475), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (162, 0), 4, delay_statement_0'Access, null);
+ Table.States (475).Kernel := To_Vector ((0 => (162, 97, 0,
False)));
+ Table.States (475).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 162, 4)));
+ Table.States (476).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (476), 97, 623);
+ Table.States (476).Kernel := To_Vector ((0 => (191, 193, 1,
False)));
+ Table.States (476).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 623)));
+ Table.States (477).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (477), 39, 123);
+ Add_Action (Table.States (477), 41, 624);
+ Add_Action (Table.States (477), 76, 127);
+ Add_Action (Table.States (477), 79, 31);
+ Add_Action (Table.States (477), 104, 130);
+ Add_Action (Table.States (477), 105, 120);
+ Add_Action (Table.States (477), 106, 34);
+ Add_Action (Table.States (477), 107, 35);
+ Table.States (477).Goto_List.Set_Capacity (6);
+ Add_Goto (Table.States (477), 118, 131);
+ Add_Goto (Table.States (477), 129, 42);
+ Add_Goto (Table.States (477), 240, 135);
+ Add_Goto (Table.States (477), 259, 257);
+ Add_Goto (Table.States (477), 273, 93);
+ Add_Goto (Table.States (477), 294, 98);
+ Table.States (477).Kernel := To_Vector (((198, 40, 1, False),
(315, 40, 6, False), (315, 40, 2, False)));
+ Table.States (477).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
+ Table.States (478).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (478), 3, 122);
+ Add_Action (Table.States (478), 39, 123);
+ Add_Action (Table.States (478), 40, 477);
+ Add_Action (Table.States (478), 41, 125);
+ Add_Action (Table.States (478), 76, 127);
+ Add_Action (Table.States (478), 79, 31);
+ Add_Action (Table.States (478), 95, 128);
+ Add_Action (Table.States (478), 96, 129);
+ Add_Action (Table.States (478), 104, 130);
+ Add_Action (Table.States (478), 105, 120);
+ Add_Action (Table.States (478), 106, 34);
+ Add_Action (Table.States (478), 107, 35);
+ Table.States (478).Goto_List.Set_Capacity (14);
+ Add_Goto (Table.States (478), 118, 131);
+ Add_Goto (Table.States (478), 129, 42);
+ Add_Goto (Table.States (478), 168, 625);
+ Add_Goto (Table.States (478), 198, 134);
+ Add_Goto (Table.States (478), 240, 480);
+ Add_Goto (Table.States (478), 259, 136);
+ Add_Goto (Table.States (478), 273, 93);
+ Add_Goto (Table.States (478), 278, 481);
+ Add_Goto (Table.States (478), 294, 98);
+ Add_Goto (Table.States (478), 302, 482);
+ Add_Goto (Table.States (478), 315, 483);
+ Add_Goto (Table.States (478), 321, 145);
+ Add_Goto (Table.States (478), 322, 146);
+ Add_Goto (Table.States (478), 331, 147);
+ Table.States (478).Kernel := To_Vector ((0 => (231, 59, 1,
False)));
+ Table.States (478).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (479).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (479), (37, 88), (231, 5), 3,
iterator_specification_5'Access, null);
+ Table.States (479).Kernel := To_Vector ((0 => (231, 168, 0,
False)));
+ Table.States (479).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 231, 3)));
end Subr_9;
procedure Subr_10
is begin
- Table.States (493).Action_List.Set_Capacity (2);
- Add_Action (Table.States (493), 81, 634);
- Add_Action (Table.States (493), 83, 234);
- Table.States (493).Kernel := To_Vector (((219, 219, 2, True),
(254, 219, 3, False), (254, 219, 2, False),
- (254, 219, 4, False), (254, 219, 3, False)));
- Table.States (493).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 81, 634)));
- Table.States (494).Action_List.Set_Capacity (2);
- Add_Action (Table.States (494), (77, 96), (255, 1), 1, null, null);
- Table.States (494).Kernel := To_Vector ((0 => (255, 254, 0,
False)));
- Table.States (494).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 255, 1)));
- Table.States (495).Action_List.Set_Capacity (2);
- Add_Action (Table.States (495), 77, 635);
- Add_Action (Table.States (495), 96, 636);
- Table.States (495).Kernel := To_Vector (((199, 255, 1, False),
(255, 255, 1, True)));
- Table.States (495).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 635)));
- Table.States (496).Action_List.Set_Capacity (7);
- Add_Action (Table.States (496), (21, 35, 56, 74, 77, 82, 96),
(252, 0), 2,
+ Table.States (480).Action_List.Set_Capacity (30);
+ Add_Action (Table.States (480), 10, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (480), 33, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (480), 37, Reduce, (315, 3), 1,
subtype_indication_3'Access, null);
+ Add_Action (Table.States (480), 38, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (480), 40, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (480), 43, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (480), 53, 626);
+ Add_Action (Table.States (480), 55, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (480), 75, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (480), 76, 627);
+ Add_Action (Table.States (480), 77, Reduce, (259, 3), 1, null,
null);
+ Add_Conflict (Table.States (480), 77, (315, 3), 1,
subtype_indication_3'Access, null);
+ Add_Action (Table.States (480), 78, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (480), 80, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (480), 84, Reduce, (259, 3), 1, null,
null);
+ Add_Conflict (Table.States (480), 84, (315, 3), 1,
subtype_indication_3'Access, null);
+ Add_Action (Table.States (480), 85, 238);
+ Add_Action (Table.States (480), 86, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (480), 87, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (480), 88, Reduce, (259, 3), 1, null,
null);
+ Add_Conflict (Table.States (480), 88, (315, 3), 1,
subtype_indication_3'Access, null);
+ Add_Action (Table.States (480), 89, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (480), 90, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (480), 92, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (480), 93, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (480), 95, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (480), 96, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (480), 98, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (480), 99, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (480), 100, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (480), 101, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (480), 102, 240);
+ Add_Action (Table.States (480), 103, 241);
+ Table.States (480).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (480), 116, 242);
+ Add_Goto (Table.States (480), 156, 628);
+ Add_Goto (Table.States (480), 225, 629);
+ Add_Goto (Table.States (480), 323, 451);
+ Table.States (480).Kernel := To_Vector (((129, 240, 2, True),
(240, 240, 5, True), (240, 240, 2, True),
+ (259, 240, 0, False), (273, 240, 3, True), (278, 240, 4, False),
(278, 240, 2, False), (294, 240, 2, True),
+ (294, 240, 2, True), (294, 240, 2, True), (294, 240, 2, True),
(315, 240, 4, False), (315, 240, 0, False)));
+ Table.States (480).Minimal_Complete_Actions := To_Vector
(((Reduce, 259, 1), (Reduce, 315, 1)));
+ Table.States (481).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (481), (37, 77, 84, 88), (168, 1), 1,
null, null);
+ Table.States (481).Kernel := To_Vector ((0 => (168, 278, 0,
False)));
+ Table.States (481).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 168, 1)));
+ Table.States (482).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (482), 86, 452);
+ Table.States (482).Kernel := To_Vector ((0 => (278, 302, 2,
False)));
+ Table.States (482).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 86, 452)));
+ Table.States (483).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (483), (37, 77, 84, 88), (168, 0), 1,
null, null);
+ Table.States (483).Kernel := To_Vector ((0 => (168, 315, 0,
False)));
+ Table.States (483).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 168, 1)));
+ Table.States (484).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (484), 79, 31);
+ Add_Action (Table.States (484), 105, 120);
+ Add_Action (Table.States (484), 106, 34);
+ Add_Action (Table.States (484), 107, 35);
+ Table.States (484).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (484), 129, 42);
+ Add_Goto (Table.States (484), 240, 630);
+ Add_Goto (Table.States (484), 273, 93);
+ Add_Goto (Table.States (484), 294, 98);
+ Table.States (484).Kernel := To_Vector ((0 => (231, 59, 1,
False)));
+ Table.States (484).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (485).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (485), 37, Reduce, (231, 4), 3, null,
null);
+ Add_Action (Table.States (485), 76, 236);
+ Add_Action (Table.States (485), 85, 238);
+ Add_Action (Table.States (485), 88, Reduce, (231, 4), 3, null,
null);
+ Add_Action (Table.States (485), 102, 240);
+ Add_Action (Table.States (485), 103, 241);
+ Table.States (485).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (485), 116, 242);
+ Add_Goto (Table.States (485), 323, 243);
+ Table.States (485).Kernel := To_Vector (((129, 240, 2, True),
(231, 240, 0, False), (240, 240, 5, True),
+ (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (485).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 231, 3)));
+ Table.States (486).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (486), 41, 631);
+ Table.States (486).Kernel := To_Vector (((315, 40, 6, False),
(315, 40, 2, False)));
+ Table.States (486).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 41, 631)));
+ Table.States (487).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (487), 10, Reduce, (315, 3), 1,
subtype_indication_3'Access, null);
+ Add_Action (Table.States (487), 21, Reduce, (315, 3), 1,
subtype_indication_3'Access, null);
+ Add_Action (Table.States (487), 42, Reduce, (315, 3), 1,
subtype_indication_3'Access, null);
+ Add_Action (Table.States (487), 53, 626);
+ Add_Action (Table.States (487), 74, Reduce, (315, 3), 1,
subtype_indication_3'Access, null);
+ Add_Action (Table.States (487), 76, 627);
+ Add_Action (Table.States (487), 83, Reduce, (315, 3), 1,
subtype_indication_3'Access, null);
+ Add_Action (Table.States (487), 85, 238);
+ Add_Action (Table.States (487), 97, Reduce, (315, 3), 1,
subtype_indication_3'Access, null);
+ Add_Action (Table.States (487), 102, 240);
+ Add_Action (Table.States (487), 103, 241);
+ Table.States (487).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (487), 116, 242);
+ Add_Goto (Table.States (487), 156, 628);
+ Add_Goto (Table.States (487), 225, 629);
+ Add_Goto (Table.States (487), 323, 243);
+ Table.States (487).Kernel := To_Vector (((129, 240, 2, True),
(240, 240, 5, True), (240, 240, 2, True),
+ (273, 240, 3, True), (294, 240, 2, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (315, 240, 4, False), (315, 240, 0, False)));
+ Table.States (487).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 315, 1)));
+ Table.States (488).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (488), 42, 632);
+ Table.States (488).Kernel := To_Vector (((231, 315, 3, False),
(231, 315, 2, False)));
+ Table.States (488).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 42, 632)));
+ Table.States (489).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (489), 97, 633);
+ Table.States (489).Kernel := To_Vector ((0 => (122, 193, 1,
False)));
+ Table.States (489).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 633)));
+ Table.States (490).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (490), 3, 122);
+ Add_Action (Table.States (490), 39, 123);
+ Add_Action (Table.States (490), 40, 124);
+ Add_Action (Table.States (490), 41, 125);
+ Add_Action (Table.States (490), 52, 126);
+ Add_Action (Table.States (490), 76, 127);
+ Add_Action (Table.States (490), 79, 31);
+ Add_Action (Table.States (490), 95, 128);
+ Add_Action (Table.States (490), 96, 129);
+ Add_Action (Table.States (490), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (490), 104, 130);
+ Add_Action (Table.States (490), 105, 120);
+ Add_Action (Table.States (490), 106, 34);
+ Add_Action (Table.States (490), 107, 35);
+ Table.States (490).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (490), 118, 131);
+ Add_Goto (Table.States (490), 129, 42);
+ Add_Goto (Table.States (490), 192, 132);
+ Add_Goto (Table.States (490), 193, 634);
+ Add_Goto (Table.States (490), 198, 134);
+ Add_Goto (Table.States (490), 240, 135);
+ Add_Goto (Table.States (490), 259, 136);
+ Add_Goto (Table.States (490), 273, 93);
+ Add_Goto (Table.States (490), 276, 137);
+ Add_Goto (Table.States (490), 283, 138);
+ Add_Goto (Table.States (490), 284, 139);
+ Add_Goto (Table.States (490), 285, 140);
+ Add_Goto (Table.States (490), 286, 141);
+ Add_Goto (Table.States (490), 287, 142);
+ Add_Goto (Table.States (490), 288, 143);
+ Add_Goto (Table.States (490), 294, 98);
+ Add_Goto (Table.States (490), 302, 144);
+ Add_Goto (Table.States (490), 321, 145);
+ Add_Goto (Table.States (490), 322, 146);
+ Add_Goto (Table.States (490), 331, 147);
+ Table.States (490).Kernel := To_Vector ((0 => (128, 12, 1,
False)));
+ Table.States (490).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (491).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (491), 12, 635);
+ Add_Action (Table.States (491), 105, Reduce, (236, 1), 0, null,
null);
+ Table.States (491).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (491), 236, 636);
+ Table.States (491).Kernel := To_Vector ((0 => (282, 54, 11,
False)));
+ Table.States (491).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 236, 0)));
+ Table.States (492).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (492), 97, 637);
+ Table.States (492).Kernel := To_Vector ((0 => (183, 118, 1,
False)));
+ Table.States (492).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 637)));
+ Table.States (493).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (493), (21, 35, 56, 74, 77, 83, 97),
(292, 1), 2, result_profile_1'Access, null);
+ Table.States (493).Kernel := To_Vector ((0 => (292, 115, 0,
True)));
+ Table.States (493).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 292, 2)));
+ Table.States (493).Minimal_Complete_Actions_Recursive := True;
+ Table.States (494).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (494), 7, 560);
+ Add_Action (Table.States (494), 21, Reduce, (241, 1), 0, null,
null);
+ Add_Action (Table.States (494), 35, Reduce, (241, 1), 0, null,
null);
+ Add_Action (Table.States (494), 56, Reduce, (241, 1), 0, null,
null);
+ Add_Action (Table.States (494), 74, Reduce, (241, 1), 0, null,
null);
+ Add_Action (Table.States (494), 77, Reduce, (241, 1), 0, null,
null);
+ Add_Action (Table.States (494), 79, 31);
+ Add_Action (Table.States (494), 83, Reduce, (241, 1), 0, null,
null);
+ Add_Action (Table.States (494), 97, Reduce, (241, 1), 0, null,
null);
+ Add_Action (Table.States (494), 105, 120);
+ Add_Action (Table.States (494), 106, 34);
+ Add_Action (Table.States (494), 107, 35);
+ Table.States (494).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (494), 129, 42);
+ Add_Goto (Table.States (494), 240, 638);
+ Add_Goto (Table.States (494), 241, 639);
+ Add_Goto (Table.States (494), 273, 93);
+ Add_Goto (Table.States (494), 294, 98);
+ Table.States (494).Kernel := To_Vector (((115, 242, 2, False),
(115, 242, 3, True), (115, 242, 2, False),
+ (292, 242, 0, False)));
+ Table.States (494).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 241, 0)));
+ Table.States (495).Action_List.Set_Capacity (30);
+ Add_Action (Table.States (495), 10, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 33, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 38, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 40, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 43, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 53, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 55, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 75, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 76, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 77, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 78, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 80, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 82, Reduce, (220, 1), 1,
identifier_list_1'Access, null);
+ Add_Action (Table.States (495), 84, Reduce, (220, 1), 1,
identifier_list_1'Access, null);
+ Add_Conflict (Table.States (495), 84, (240, 5), 1, name_5'Access,
name_5_check'Access);
+ Add_Action (Table.States (495), 85, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 86, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 87, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 88, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 89, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 90, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 92, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 93, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 95, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 96, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 98, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 99, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 100, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 101, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 102, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (495), 103, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Table.States (495).Kernel := To_Vector (((220, 105, 0, False),
(240, 105, 0, False)));
+ Table.States (495).Minimal_Complete_Actions := To_Vector
(((Reduce, 220, 1), (Reduce, 240, 1)));
+ Table.States (496).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (496), 82, 640);
+ Add_Action (Table.States (496), 84, 235);
+ Table.States (496).Kernel := To_Vector (((220, 220, 2, True),
(255, 220, 3, False), (255, 220, 2, False),
+ (255, 220, 4, False), (255, 220, 3, False)));
+ Table.States (496).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 82, 640)));
+ Table.States (497).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (497), (77, 97), (256, 1), 1, null, null);
+ Table.States (497).Kernel := To_Vector ((0 => (256, 255, 0,
False)));
+ Table.States (497).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 256, 1)));
+ Table.States (498).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (498), 77, 641);
+ Add_Action (Table.States (498), 97, 642);
+ Table.States (498).Kernel := To_Vector (((200, 256, 1, False),
(256, 256, 1, True)));
+ Table.States (498).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 641)));
+ Table.States (499).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (499), (21, 35, 56, 74, 77, 83, 97),
(253, 0), 2,
parameter_and_result_profile_0'Access, null);
- Table.States (496).Kernel := To_Vector ((0 => (252, 291, 0,
True)));
- Table.States (496).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 252, 2)));
- Table.States (496).Minimal_Complete_Actions_Recursive := True;
- Table.States (497).Action_List.Set_Capacity (3);
- Add_Action (Table.States (497), 104, 119);
- Add_Action (Table.States (497), 105, 33);
- Add_Action (Table.States (497), 106, 34);
- Table.States (497).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (497), 128, 41);
- Add_Goto (Table.States (497), 239, 637);
- Add_Goto (Table.States (497), 272, 92);
- Add_Goto (Table.States (497), 293, 97);
- Table.States (497).Kernel := To_Vector ((0 => (215, 56, 2,
False)));
- Table.States (497).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (498).Action_List.Set_Capacity (3);
- Add_Action (Table.States (498), 104, 119);
- Add_Action (Table.States (498), 105, 33);
- Add_Action (Table.States (498), 106, 34);
- Table.States (498).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (498), 128, 41);
- Add_Goto (Table.States (498), 239, 638);
- Add_Goto (Table.States (498), 272, 92);
- Add_Goto (Table.States (498), 293, 97);
- Table.States (498).Kernel := To_Vector ((0 => (215, 56, 2,
False)));
- Table.States (498).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (499).Action_List.Set_Capacity (3);
- Add_Action (Table.States (499), 104, 119);
- Add_Action (Table.States (499), 105, 33);
- Add_Action (Table.States (499), 106, 34);
- Table.States (499).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (499), 128, 41);
- Add_Goto (Table.States (499), 239, 639);
- Add_Goto (Table.States (499), 272, 92);
- Add_Goto (Table.States (499), 293, 97);
- Table.States (499).Kernel := To_Vector ((0 => (215, 56, 2,
False)));
- Table.States (499).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (500).Action_List.Set_Capacity (3);
- Add_Action (Table.States (500), 35, 640);
- Add_Action (Table.States (500), 74, 337);
- Add_Action (Table.States (500), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (500).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (500), 122, 641);
- Table.States (500).Kernel := To_Vector (((201, 169, 3, False),
(201, 169, 3, False), (201, 169, 1,
- False)));
- Table.States (500).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (501).Action_List.Set_Capacity (5);
- Add_Action (Table.States (501), 35, 642);
- Add_Action (Table.States (501), 76, 235);
- Add_Action (Table.States (501), 84, 237);
- Add_Action (Table.States (501), 101, 239);
- Add_Action (Table.States (501), 102, 240);
- Table.States (501).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (501), 115, 241);
- Add_Goto (Table.States (501), 322, 242);
- Table.States (501).Kernel := To_Vector (((128, 239, 2, True),
(204, 239, 4, False), (239, 239, 5, True),
- (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (501).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 642)));
- Table.States (502).Action_List.Set_Capacity (6);
- Add_Action (Table.States (502), 6, 643);
- Add_Action (Table.States (502), 41, 644);
- Add_Action (Table.States (502), 80, 645);
- Add_Action (Table.States (502), 104, 119);
- Add_Action (Table.States (502), 105, 33);
+ Table.States (499).Kernel := To_Vector ((0 => (253, 292, 0,
True)));
+ Table.States (499).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 253, 2)));
+ Table.States (499).Minimal_Complete_Actions_Recursive := True;
+ Table.States (500).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (500), 79, 31);
+ Add_Action (Table.States (500), 105, 120);
+ Add_Action (Table.States (500), 106, 34);
+ Add_Action (Table.States (500), 107, 35);
+ Table.States (500).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (500), 129, 42);
+ Add_Goto (Table.States (500), 240, 643);
+ Add_Goto (Table.States (500), 273, 93);
+ Add_Goto (Table.States (500), 294, 98);
+ Table.States (500).Kernel := To_Vector ((0 => (216, 56, 2,
False)));
+ Table.States (500).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (501).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (501), 79, 31);
+ Add_Action (Table.States (501), 105, 120);
+ Add_Action (Table.States (501), 106, 34);
+ Add_Action (Table.States (501), 107, 35);
+ Table.States (501).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (501), 129, 42);
+ Add_Goto (Table.States (501), 240, 644);
+ Add_Goto (Table.States (501), 273, 93);
+ Add_Goto (Table.States (501), 294, 98);
+ Table.States (501).Kernel := To_Vector ((0 => (216, 56, 2,
False)));
+ Table.States (501).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (502).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (502), 79, 31);
+ Add_Action (Table.States (502), 105, 120);
Add_Action (Table.States (502), 106, 34);
- Table.States (502).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (502), 128, 41);
- Add_Goto (Table.States (502), 239, 646);
- Add_Goto (Table.States (502), 272, 92);
- Add_Goto (Table.States (502), 293, 97);
- Add_Goto (Table.States (502), 310, 647);
- Table.States (502).Kernel := To_Vector (((200, 35, 3, False),
(200, 35, 2, False), (200, 35, 2, False)));
- Table.States (502).Minimal_Complete_Actions := To_Vector (((Shift,
104, 119), (Shift, 6, 643)));
- Table.States (503).Action_List.Set_Capacity (1);
- Add_Action (Table.States (503), 96, 648);
- Table.States (503).Kernel := To_Vector ((0 => (200, 122, 1,
False)));
- Table.States (503).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 648)));
- Table.States (504).Action_List.Set_Capacity (9);
- Add_Action (Table.States (504), 7, Reduce, (236, 0), 1, null,
null);
- Add_Action (Table.States (504), 40, Reduce, (236, 0), 1, null,
null);
- Add_Action (Table.States (504), 45, 649);
- Add_Action (Table.States (504), 74, Reduce, (236, 0), 1, null,
null);
- Add_Action (Table.States (504), 82, Reduce, (236, 0), 1, null,
null);
- Add_Action (Table.States (504), 96, Reduce, (236, 0), 1, null,
null);
- Add_Action (Table.States (504), 104, Reduce, (236, 0), 1, null,
null);
- Add_Action (Table.States (504), 105, Reduce, (236, 0), 1, null,
null);
- Add_Action (Table.States (504), 106, Reduce, (236, 0), 1, null,
null);
- Table.States (504).Kernel := To_Vector (((236, 33, 0, False),
(236, 33, 1, False)));
- Table.States (504).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 236, 1)));
- Table.States (505).Action_List.Set_Capacity (8);
- Add_Action (Table.States (505), (7, 40, 74, 82, 96, 104, 105,
106), (236, 2), 1, null, null);
- Table.States (505).Kernel := To_Vector ((0 => (236, 45, 0,
False)));
- Table.States (505).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 236, 1)));
- Table.States (506).Action_List.Set_Capacity (5);
- Add_Action (Table.States (506), 7, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (506), 40, 386);
- Add_Action (Table.States (506), 104, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (506), 105, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (506), 106, Reduce, (241, 1), 0, null,
null);
- Table.States (506).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (506), 114, 650);
- Add_Goto (Table.States (506), 241, 651);
- Table.States (506).Kernel := To_Vector (((198, 236, 3, False),
(198, 236, 4, False), (198, 236, 2, False),
- (198, 236, 3, False)));
- Table.States (506).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 241, 0)));
- Table.States (507).Action_List.Set_Capacity (3);
- Add_Action (Table.States (507), 22, 652);
- Add_Action (Table.States (507), 23, 653);
- Add_Action (Table.States (507), 24, 654);
- Table.States (507).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (507), 174, 655);
- Add_Goto (Table.States (507), 175, 656);
- Table.States (507).Kernel := To_Vector (((222, 300, 6, False),
(222, 300, 4, False), (222, 300, 5, False),
- (222, 300, 3, False)));
- Table.States (507).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 654)));
- Table.States (508).Action_List.Set_Capacity (2);
- Add_Action (Table.States (508), 83, 381);
- Add_Action (Table.States (508), 96, 657);
- Table.States (508).Kernel := To_Vector (((238, 238, 2, True),
(332, 238, 1, False)));
- Table.States (508).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 657)));
- Table.States (509).Action_List.Set_Capacity (39);
- Add_Action (Table.States (509), (4, 5, 13, 15, 17, 18, 25, 27, 28,
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
- 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93,
104, 105, 106, 107), (332, 1), 4,
+ Add_Action (Table.States (502), 107, 35);
+ Table.States (502).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (502), 129, 42);
+ Add_Goto (Table.States (502), 240, 645);
+ Add_Goto (Table.States (502), 273, 93);
+ Add_Goto (Table.States (502), 294, 98);
+ Table.States (502).Kernel := To_Vector ((0 => (216, 56, 2,
False)));
+ Table.States (502).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (503).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (503), 35, 646);
+ Add_Action (Table.States (503), 74, 338);
+ Add_Action (Table.States (503), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (503).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (503), 123, 647);
+ Table.States (503).Kernel := To_Vector (((202, 170, 3, False),
(202, 170, 3, False), (202, 170, 1,
+ False)));
+ Table.States (503).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (504).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (504), 35, 648);
+ Add_Action (Table.States (504), 76, 236);
+ Add_Action (Table.States (504), 85, 238);
+ Add_Action (Table.States (504), 102, 240);
+ Add_Action (Table.States (504), 103, 241);
+ Table.States (504).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (504), 116, 242);
+ Add_Goto (Table.States (504), 323, 243);
+ Table.States (504).Kernel := To_Vector (((129, 240, 2, True),
(205, 240, 4, False), (240, 240, 5, True),
+ (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (504).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 648)));
+ Table.States (505).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (505), 6, 649);
+ Add_Action (Table.States (505), 41, 650);
+ Add_Action (Table.States (505), 79, 31);
+ Add_Action (Table.States (505), 81, 651);
+ Add_Action (Table.States (505), 105, 120);
+ Add_Action (Table.States (505), 106, 34);
+ Add_Action (Table.States (505), 107, 35);
+ Table.States (505).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (505), 129, 42);
+ Add_Goto (Table.States (505), 240, 652);
+ Add_Goto (Table.States (505), 273, 93);
+ Add_Goto (Table.States (505), 294, 98);
+ Add_Goto (Table.States (505), 311, 653);
+ Table.States (505).Kernel := To_Vector (((201, 35, 3, False),
(201, 35, 2, False), (201, 35, 2, False)));
+ Table.States (505).Minimal_Complete_Actions := To_Vector (((Shift,
105, 120), (Shift, 6, 649)));
+ Table.States (506).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (506), 97, 654);
+ Table.States (506).Kernel := To_Vector ((0 => (201, 123, 1,
False)));
+ Table.States (506).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 654)));
+ Table.States (507).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (507), 7, Reduce, (237, 0), 1, null,
null);
+ Add_Action (Table.States (507), 40, Reduce, (237, 0), 1, null,
null);
+ Add_Action (Table.States (507), 45, 655);
+ Add_Action (Table.States (507), 74, Reduce, (237, 0), 1, null,
null);
+ Add_Action (Table.States (507), 79, Reduce, (237, 0), 1, null,
null);
+ Add_Action (Table.States (507), 83, Reduce, (237, 0), 1, null,
null);
+ Add_Action (Table.States (507), 97, Reduce, (237, 0), 1, null,
null);
+ Add_Action (Table.States (507), 105, Reduce, (237, 0), 1, null,
null);
+ Add_Action (Table.States (507), 106, Reduce, (237, 0), 1, null,
null);
+ Add_Action (Table.States (507), 107, Reduce, (237, 0), 1, null,
null);
+ Table.States (507).Kernel := To_Vector (((237, 33, 0, False),
(237, 33, 1, False)));
+ Table.States (507).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 237, 1)));
+ Table.States (508).Action_List.Set_Capacity (9);
+ Add_Action (Table.States (508), (7, 40, 74, 79, 83, 97, 105, 106,
107), (237, 2), 1, null, null);
+ Table.States (508).Kernel := To_Vector ((0 => (237, 45, 0,
False)));
+ Table.States (508).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 237, 1)));
+ Table.States (509).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (509), 7, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (509), 40, 387);
+ Add_Action (Table.States (509), 79, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (509), 105, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (509), 106, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (509), 107, Reduce, (242, 1), 0, null,
null);
+ Table.States (509).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (509), 115, 656);
+ Add_Goto (Table.States (509), 242, 657);
+ Table.States (509).Kernel := To_Vector (((199, 237, 3, False),
(199, 237, 4, False), (199, 237, 2, False),
+ (199, 237, 3, False)));
+ Table.States (509).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 242, 0)));
+ Table.States (510).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (510), 22, 658);
+ Add_Action (Table.States (510), 23, 659);
+ Add_Action (Table.States (510), 24, 660);
+ Table.States (510).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (510), 175, 661);
+ Add_Goto (Table.States (510), 176, 662);
+ Table.States (510).Kernel := To_Vector (((223, 301, 6, False),
(223, 301, 4, False), (223, 301, 5, False),
+ (223, 301, 3, False)));
+ Table.States (510).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 660)));
+ Table.States (511).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (511), 84, 382);
+ Add_Action (Table.States (511), 97, 663);
+ Table.States (511).Kernel := To_Vector (((239, 239, 2, True),
(333, 239, 1, False)));
+ Table.States (511).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 663)));
+ Table.States (512).Action_List.Set_Capacity (40);
+ Add_Action (Table.States (512), (4, 5, 13, 15, 17, 18, 25, 27, 28,
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
+ 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 79,
94, 105, 106, 107, 108), (333, 1), 4,
with_clause_1'Access, null);
- Table.States (509).Kernel := To_Vector ((0 => (332, 96, 0,
False)));
- Table.States (509).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 332, 4)));
- Table.States (510).Action_List.Set_Capacity (1);
- Add_Action (Table.States (510), 60, 658);
- Table.States (510).Kernel := To_Vector ((0 => (248, 35, 2,
False)));
- Table.States (510).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 60, 658)));
- Table.States (511).Action_List.Set_Capacity (1);
- Add_Action (Table.States (511), 35, 659);
- Table.States (511).Kernel := To_Vector (((247, 122, 4, False),
(247, 122, 3, False)));
- Table.States (511).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 659)));
- Table.States (512).Action_List.Set_Capacity (3);
- Add_Action (Table.States (512), 104, 119);
- Add_Action (Table.States (512), 105, 33);
- Add_Action (Table.States (512), 106, 34);
- Table.States (512).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (512), 128, 41);
- Add_Goto (Table.States (512), 239, 660);
- Add_Goto (Table.States (512), 272, 92);
- Add_Goto (Table.States (512), 293, 97);
- Table.States (512).Kernel := To_Vector ((0 => (213, 39, 2,
False)));
- Table.States (512).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (513).Action_List.Set_Capacity (6);
- Add_Action (Table.States (513), 74, 337);
- Add_Action (Table.States (513), 76, 235);
- Add_Action (Table.States (513), 84, 237);
- Add_Action (Table.States (513), 96, Reduce, (122, 1), 0, null,
null);
- Add_Action (Table.States (513), 101, 239);
- Add_Action (Table.States (513), 102, 240);
- Table.States (513).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (513), 115, 241);
- Add_Goto (Table.States (513), 122, 661);
- Add_Goto (Table.States (513), 322, 242);
- Table.States (513).Kernel := To_Vector (((128, 239, 2, True),
(239, 239, 5, True), (239, 239, 2, True),
- (250, 239, 1, False), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (513).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (514).Action_List.Set_Capacity (3);
- Add_Action (Table.States (514), 35, Reduce, (122, 0), 2,
aspect_specification_opt_0'Access, null);
- Add_Action (Table.States (514), 83, 443);
- Add_Action (Table.States (514), 96, Reduce, (122, 0), 2,
aspect_specification_opt_0'Access, null);
- Table.States (514).Kernel := To_Vector (((122, 125, 0, False),
(125, 125, 1, True)));
- Table.States (514).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 2)));
- Table.States (515).Action_List.Set_Capacity (17);
- Add_Action (Table.States (515), 24, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (515), 25, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (515), 28, 183);
- Add_Action (Table.States (515), 29, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (515), 30, 8);
- Add_Action (Table.States (515), 40, 12);
- Add_Action (Table.States (515), 46, 14);
- Add_Action (Table.States (515), 47, 15);
- Add_Action (Table.States (515), 48, 16);
- Add_Action (Table.States (515), 49, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (515), 50, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (515), 51, 19);
- Add_Action (Table.States (515), 63, 25);
- Add_Action (Table.States (515), 66, 26);
- Add_Action (Table.States (515), 69, 27);
- Add_Action (Table.States (515), 71, 28);
- Add_Action (Table.States (515), 104, 185);
- Table.States (515).Goto_List.Set_Capacity (53);
- Add_Goto (Table.States (515), 112, 35);
- Add_Goto (Table.States (515), 121, 37);
- Add_Goto (Table.States (515), 127, 40);
- Add_Goto (Table.States (515), 134, 45);
- Add_Goto (Table.States (515), 135, 46);
- Add_Goto (Table.States (515), 157, 391);
- Add_Goto (Table.States (515), 158, 392);
- Add_Goto (Table.States (515), 159, 662);
- Add_Goto (Table.States (515), 179, 54);
- Add_Goto (Table.States (515), 182, 55);
- Add_Goto (Table.States (515), 186, 56);
- Add_Goto (Table.States (515), 193, 58);
- Add_Goto (Table.States (515), 206, 60);
- Add_Goto (Table.States (515), 207, 61);
- Add_Goto (Table.States (515), 209, 62);
- Add_Goto (Table.States (515), 210, 63);
- Add_Goto (Table.States (515), 213, 64);
- Add_Goto (Table.States (515), 214, 65);
- Add_Goto (Table.States (515), 215, 66);
- Add_Goto (Table.States (515), 216, 67);
- Add_Goto (Table.States (515), 219, 69);
- Add_Goto (Table.States (515), 223, 71);
- Add_Goto (Table.States (515), 243, 74);
- Add_Goto (Table.States (515), 244, 75);
- Add_Goto (Table.States (515), 245, 76);
- Add_Goto (Table.States (515), 246, 77);
- Add_Goto (Table.States (515), 247, 78);
- Add_Goto (Table.States (515), 248, 79);
- Add_Goto (Table.States (515), 249, 80);
- Add_Goto (Table.States (515), 250, 81);
- Add_Goto (Table.States (515), 251, 82);
- Add_Goto (Table.States (515), 257, 394);
- Add_Goto (Table.States (515), 259, 84);
- Add_Goto (Table.States (515), 260, 85);
- Add_Goto (Table.States (515), 262, 87);
- Add_Goto (Table.States (515), 263, 88);
- Add_Goto (Table.States (515), 264, 89);
- Add_Goto (Table.States (515), 265, 90);
- Add_Goto (Table.States (515), 271, 91);
- Add_Goto (Table.States (515), 281, 94);
- Add_Goto (Table.States (515), 289, 95);
- Add_Goto (Table.States (515), 304, 102);
- Add_Goto (Table.States (515), 305, 103);
- Add_Goto (Table.States (515), 307, 105);
- Add_Goto (Table.States (515), 308, 106);
- Add_Goto (Table.States (515), 309, 107);
- Add_Goto (Table.States (515), 311, 108);
- Add_Goto (Table.States (515), 313, 109);
- Add_Goto (Table.States (515), 316, 111);
- Add_Goto (Table.States (515), 317, 112);
- Add_Goto (Table.States (515), 319, 113);
- Add_Goto (Table.States (515), 325, 115);
- Add_Goto (Table.States (515), 331, 116);
- Table.States (515).Kernel := To_Vector (((251, 35, 2, False),
(251, 35, 1, False)));
- Table.States (515).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 159, 0)));
- Table.States (516).Action_List.Set_Capacity (2);
- Add_Action (Table.States (516), 77, 663);
- Add_Action (Table.States (516), 83, 443);
- Table.States (516).Kernel := To_Vector (((125, 125, 1, True),
(257, 125, 2, False)));
- Table.States (516).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 663)));
+ Table.States (512).Kernel := To_Vector ((0 => (333, 97, 0,
False)));
+ Table.States (512).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 333, 4)));
+ Table.States (513).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (513), 60, 664);
+ Table.States (513).Kernel := To_Vector ((0 => (249, 35, 2,
False)));
+ Table.States (513).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 60, 664)));
+ Table.States (514).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (514), 35, 665);
+ Table.States (514).Kernel := To_Vector (((248, 123, 4, False),
(248, 123, 3, False)));
+ Table.States (514).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 665)));
+ Table.States (515).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (515), 79, 31);
+ Add_Action (Table.States (515), 105, 120);
+ Add_Action (Table.States (515), 106, 34);
+ Add_Action (Table.States (515), 107, 35);
+ Table.States (515).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (515), 129, 42);
+ Add_Goto (Table.States (515), 240, 666);
+ Add_Goto (Table.States (515), 273, 93);
+ Add_Goto (Table.States (515), 294, 98);
+ Table.States (515).Kernel := To_Vector ((0 => (214, 39, 2,
False)));
+ Table.States (515).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (516).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (516), 74, 338);
+ Add_Action (Table.States (516), 76, 236);
+ Add_Action (Table.States (516), 85, 238);
+ Add_Action (Table.States (516), 97, Reduce, (123, 1), 0, null,
null);
+ Add_Action (Table.States (516), 102, 240);
+ Add_Action (Table.States (516), 103, 241);
+ Table.States (516).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (516), 116, 242);
+ Add_Goto (Table.States (516), 123, 667);
+ Add_Goto (Table.States (516), 323, 243);
+ Table.States (516).Kernel := To_Vector (((129, 240, 2, True),
(240, 240, 5, True), (240, 240, 2, True),
+ (251, 240, 1, False), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (516).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
Table.States (517).Action_List.Set_Capacity (1);
- Add_Action (Table.States (517), 77, 664);
- Table.States (517).Kernel := To_Vector ((0 => (257, 153, 2,
False)));
- Table.States (517).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 664)));
- Table.States (518).Action_List.Set_Capacity (39);
- Add_Action (Table.States (518), (4, 5, 13, 15, 17, 18, 25, 27, 28,
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
- 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93,
104, 105, 106, 107), (332, 2), 4,
+ Add_Action (Table.States (517), 105, 438);
+ Table.States (517).Kernel := To_Vector ((0 => (125, 28, 4,
False)));
+ Table.States (517).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 438)));
+ Table.States (518).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (518), 35, Reduce, (123, 0), 2,
aspect_specification_opt_0'Access, null);
+ Add_Action (Table.States (518), 84, 445);
+ Add_Action (Table.States (518), 97, Reduce, (123, 0), 2,
aspect_specification_opt_0'Access, null);
+ Table.States (518).Kernel := To_Vector (((123, 126, 0, False),
(126, 126, 1, True)));
+ Table.States (518).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 2)));
+ Table.States (519).Action_List.Set_Capacity (17);
+ Add_Action (Table.States (519), 24, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (519), 25, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (519), 28, 184);
+ Add_Action (Table.States (519), 29, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (519), 30, 8);
+ Add_Action (Table.States (519), 40, 12);
+ Add_Action (Table.States (519), 46, 14);
+ Add_Action (Table.States (519), 47, 15);
+ Add_Action (Table.States (519), 48, 16);
+ Add_Action (Table.States (519), 49, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (519), 50, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (519), 51, 19);
+ Add_Action (Table.States (519), 63, 25);
+ Add_Action (Table.States (519), 66, 26);
+ Add_Action (Table.States (519), 69, 27);
+ Add_Action (Table.States (519), 71, 28);
+ Add_Action (Table.States (519), 105, 186);
+ Table.States (519).Goto_List.Set_Capacity (53);
+ Add_Goto (Table.States (519), 113, 36);
+ Add_Goto (Table.States (519), 122, 38);
+ Add_Goto (Table.States (519), 128, 41);
+ Add_Goto (Table.States (519), 135, 46);
+ Add_Goto (Table.States (519), 136, 47);
+ Add_Goto (Table.States (519), 158, 392);
+ Add_Goto (Table.States (519), 159, 393);
+ Add_Goto (Table.States (519), 160, 668);
+ Add_Goto (Table.States (519), 180, 55);
+ Add_Goto (Table.States (519), 183, 56);
+ Add_Goto (Table.States (519), 187, 57);
+ Add_Goto (Table.States (519), 194, 59);
+ Add_Goto (Table.States (519), 207, 61);
+ Add_Goto (Table.States (519), 208, 62);
+ Add_Goto (Table.States (519), 210, 63);
+ Add_Goto (Table.States (519), 211, 64);
+ Add_Goto (Table.States (519), 214, 65);
+ Add_Goto (Table.States (519), 215, 66);
+ Add_Goto (Table.States (519), 216, 67);
+ Add_Goto (Table.States (519), 217, 68);
+ Add_Goto (Table.States (519), 220, 70);
+ Add_Goto (Table.States (519), 224, 72);
+ Add_Goto (Table.States (519), 244, 75);
+ Add_Goto (Table.States (519), 245, 76);
+ Add_Goto (Table.States (519), 246, 77);
+ Add_Goto (Table.States (519), 247, 78);
+ Add_Goto (Table.States (519), 248, 79);
+ Add_Goto (Table.States (519), 249, 80);
+ Add_Goto (Table.States (519), 250, 81);
+ Add_Goto (Table.States (519), 251, 82);
+ Add_Goto (Table.States (519), 252, 83);
+ Add_Goto (Table.States (519), 258, 395);
+ Add_Goto (Table.States (519), 260, 85);
+ Add_Goto (Table.States (519), 261, 86);
+ Add_Goto (Table.States (519), 263, 88);
+ Add_Goto (Table.States (519), 264, 89);
+ Add_Goto (Table.States (519), 265, 90);
+ Add_Goto (Table.States (519), 266, 91);
+ Add_Goto (Table.States (519), 272, 92);
+ Add_Goto (Table.States (519), 282, 95);
+ Add_Goto (Table.States (519), 290, 96);
+ Add_Goto (Table.States (519), 305, 103);
+ Add_Goto (Table.States (519), 306, 104);
+ Add_Goto (Table.States (519), 308, 106);
+ Add_Goto (Table.States (519), 309, 107);
+ Add_Goto (Table.States (519), 310, 108);
+ Add_Goto (Table.States (519), 312, 109);
+ Add_Goto (Table.States (519), 314, 110);
+ Add_Goto (Table.States (519), 317, 112);
+ Add_Goto (Table.States (519), 318, 113);
+ Add_Goto (Table.States (519), 320, 114);
+ Add_Goto (Table.States (519), 326, 116);
+ Add_Goto (Table.States (519), 332, 117);
+ Table.States (519).Kernel := To_Vector (((252, 35, 2, False),
(252, 35, 1, False)));
+ Table.States (519).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 160, 0)));
+ Table.States (520).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (520), 77, 669);
+ Add_Action (Table.States (520), 84, 445);
+ Table.States (520).Kernel := To_Vector (((126, 126, 1, True),
(258, 126, 2, False)));
+ Table.States (520).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 669)));
+ Table.States (521).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (521), 77, 670);
+ Table.States (521).Kernel := To_Vector ((0 => (258, 154, 2,
False)));
+ Table.States (521).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 670)));
+ Table.States (522).Action_List.Set_Capacity (40);
+ Add_Action (Table.States (522), (4, 5, 13, 15, 17, 18, 25, 27, 28,
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
+ 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 79,
94, 105, 106, 107, 108), (333, 2), 4,
with_clause_2'Access, null);
- Table.States (518).Kernel := To_Vector ((0 => (332, 96, 0,
False)));
- Table.States (518).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 332, 4)));
- Table.States (519).Action_List.Set_Capacity (1);
- Add_Action (Table.States (519), 60, 665);
- Table.States (519).Kernel := To_Vector ((0 => (265, 35, 2,
False)));
- Table.States (519).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 60, 665)));
- Table.States (520).Action_List.Set_Capacity (1);
- Add_Action (Table.States (520), 35, 666);
- Table.States (520).Kernel := To_Vector ((0 => (264, 122, 3,
False)));
- Table.States (520).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 666)));
- Table.States (521).Action_List.Set_Capacity (2);
- Add_Action (Table.States (521), 35, Reduce, (122, 1), 0, null,
null);
- Add_Action (Table.States (521), 74, 337);
- Table.States (521).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (521), 122, 667);
- Table.States (521).Kernel := To_Vector (((271, 169, 6, False),
(271, 169, 3, False)));
- Table.States (521).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (522).Action_List.Set_Capacity (18);
- Add_Action (Table.States (522), 24, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (522), 25, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (522), 28, 183);
- Add_Action (Table.States (522), 29, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (522), 30, 8);
- Add_Action (Table.States (522), 39, 668);
- Add_Action (Table.States (522), 40, 12);
- Add_Action (Table.States (522), 46, 14);
- Add_Action (Table.States (522), 47, 15);
- Add_Action (Table.States (522), 48, 16);
- Add_Action (Table.States (522), 49, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (522), 50, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (522), 51, 19);
- Add_Action (Table.States (522), 63, 25);
- Add_Action (Table.States (522), 66, 26);
- Add_Action (Table.States (522), 69, 27);
- Add_Action (Table.States (522), 71, 28);
- Add_Action (Table.States (522), 104, 185);
- Table.States (522).Goto_List.Set_Capacity (54);
- Add_Goto (Table.States (522), 112, 35);
- Add_Goto (Table.States (522), 121, 37);
- Add_Goto (Table.States (522), 127, 40);
- Add_Goto (Table.States (522), 134, 45);
- Add_Goto (Table.States (522), 135, 46);
- Add_Goto (Table.States (522), 157, 391);
- Add_Goto (Table.States (522), 158, 392);
- Add_Goto (Table.States (522), 159, 669);
- Add_Goto (Table.States (522), 179, 54);
- Add_Goto (Table.States (522), 182, 55);
- Add_Goto (Table.States (522), 186, 56);
- Add_Goto (Table.States (522), 193, 58);
- Add_Goto (Table.States (522), 206, 60);
- Add_Goto (Table.States (522), 207, 61);
- Add_Goto (Table.States (522), 209, 62);
- Add_Goto (Table.States (522), 210, 63);
- Add_Goto (Table.States (522), 213, 64);
- Add_Goto (Table.States (522), 214, 65);
- Add_Goto (Table.States (522), 215, 66);
- Add_Goto (Table.States (522), 216, 67);
- Add_Goto (Table.States (522), 219, 69);
- Add_Goto (Table.States (522), 223, 71);
- Add_Goto (Table.States (522), 243, 74);
- Add_Goto (Table.States (522), 244, 75);
- Add_Goto (Table.States (522), 245, 76);
- Add_Goto (Table.States (522), 246, 77);
- Add_Goto (Table.States (522), 247, 78);
- Add_Goto (Table.States (522), 248, 79);
- Add_Goto (Table.States (522), 249, 80);
- Add_Goto (Table.States (522), 250, 81);
- Add_Goto (Table.States (522), 251, 82);
- Add_Goto (Table.States (522), 257, 394);
- Add_Goto (Table.States (522), 259, 84);
- Add_Goto (Table.States (522), 260, 85);
- Add_Goto (Table.States (522), 262, 87);
- Add_Goto (Table.States (522), 263, 88);
- Add_Goto (Table.States (522), 264, 89);
- Add_Goto (Table.States (522), 265, 90);
- Add_Goto (Table.States (522), 266, 670);
- Add_Goto (Table.States (522), 271, 91);
- Add_Goto (Table.States (522), 281, 94);
- Add_Goto (Table.States (522), 289, 95);
- Add_Goto (Table.States (522), 304, 102);
- Add_Goto (Table.States (522), 305, 103);
- Add_Goto (Table.States (522), 307, 105);
- Add_Goto (Table.States (522), 308, 106);
- Add_Goto (Table.States (522), 309, 107);
- Add_Goto (Table.States (522), 311, 108);
- Add_Goto (Table.States (522), 313, 109);
- Add_Goto (Table.States (522), 316, 111);
- Add_Goto (Table.States (522), 317, 112);
- Add_Goto (Table.States (522), 319, 113);
- Add_Goto (Table.States (522), 325, 115);
- Add_Goto (Table.States (522), 331, 116);
- Table.States (522).Kernel := To_Vector (((304, 35, 5, False),
(304, 35, 2, False)));
- Table.States (522).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 159, 0)));
+ Table.States (522).Kernel := To_Vector ((0 => (333, 97, 0,
False)));
+ Table.States (522).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 333, 4)));
Table.States (523).Action_List.Set_Capacity (1);
- Add_Action (Table.States (523), 96, 671);
- Table.States (523).Kernel := To_Vector ((0 => (276, 192, 1,
False)));
- Table.States (523).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 671)));
+ Add_Action (Table.States (523), 60, 671);
+ Table.States (523).Kernel := To_Vector ((0 => (266, 35, 2,
False)));
+ Table.States (523).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 60, 671)));
Table.States (524).Action_List.Set_Capacity (1);
- Add_Action (Table.States (524), 96, 672);
- Table.States (524).Kernel := To_Vector ((0 => (290, 5, 1, False)));
- Table.States (524).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 672)));
- Table.States (525).Action_List.Set_Capacity (9);
- Add_Action (Table.States (525), 7, Reduce, (154, 1), 0, null,
null);
- Add_Action (Table.States (525), 16, 568);
- Add_Action (Table.States (525), 21, Reduce, (154, 1), 0, null,
null);
- Add_Action (Table.States (525), 40, Reduce, (154, 1), 0, null,
null);
- Add_Action (Table.States (525), 82, Reduce, (154, 1), 0, null,
null);
- Add_Action (Table.States (525), 96, Reduce, (154, 1), 0, null,
null);
- Add_Action (Table.States (525), 104, Reduce, (154, 1), 0, null,
null);
- Add_Action (Table.States (525), 105, Reduce, (154, 1), 0, null,
null);
- Add_Action (Table.States (525), 106, Reduce, (154, 1), 0, null,
null);
+ Add_Action (Table.States (524), 35, 672);
+ Table.States (524).Kernel := To_Vector ((0 => (265, 123, 3,
False)));
+ Table.States (524).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 672)));
+ Table.States (525).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (525), 35, Reduce, (123, 1), 0, null,
null);
+ Add_Action (Table.States (525), 74, 338);
Table.States (525).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (525), 154, 673);
- Table.States (525).Kernel := To_Vector (((194, 118, 2, False),
(194, 118, 1, False)));
- Table.States (525).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 154, 0)));
- Table.States (526).Action_List.Set_Capacity (1);
- Add_Action (Table.States (526), 24, 674);
- Table.States (526).Kernel := To_Vector ((0 => (196, 218, 3,
False)));
- Table.States (526).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 674)));
- Table.States (527).Action_List.Set_Capacity (7);
- Add_Action (Table.States (527), 29, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (527), 40, 12);
- Add_Action (Table.States (527), 46, 14);
- Add_Action (Table.States (527), 47, 675);
- Add_Action (Table.States (527), 50, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (527), 51, 676);
- Add_Action (Table.States (527), 66, 677);
- Table.States (527).Goto_List.Set_Capacity (8);
- Add_Goto (Table.States (527), 207, 61);
- Add_Goto (Table.States (527), 246, 678);
- Add_Goto (Table.States (527), 247, 78);
- Add_Goto (Table.States (527), 262, 87);
- Add_Goto (Table.States (527), 263, 679);
- Add_Goto (Table.States (527), 264, 89);
- Add_Goto (Table.States (527), 307, 105);
- Add_Goto (Table.States (527), 316, 111);
- Table.States (527).Kernel := To_Vector ((0 => (315, 77, 6,
False)));
- Table.States (527).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 246, 0)));
- Table.States (528).Action_List.Set_Capacity (3);
- Add_Action (Table.States (528), 4, 1);
- Add_Action (Table.States (528), 18, 4);
- Add_Action (Table.States (528), 67, 680);
- Table.States (528).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (528), 113, 681);
- Add_Goto (Table.States (528), 160, 682);
- Add_Goto (Table.States (528), 161, 533);
- Table.States (528).Kernel := To_Vector (((295, 87, 3, False),
(295, 87, 2, False), (295, 87, 2, False)));
- Table.States (528).Minimal_Complete_Actions := To_Vector (((Shift,
67, 680), (Shift, 18, 4)));
- Table.States (529).Action_List.Set_Capacity (5);
- Add_Action (Table.States (529), (13, 17, 28, 37, 73), (131, 0), 2,
block_label_0'Access,
+ Add_Goto (Table.States (525), 123, 673);
+ Table.States (525).Kernel := To_Vector (((272, 170, 6, False),
(272, 170, 3, False)));
+ Table.States (525).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (526).Action_List.Set_Capacity (18);
+ Add_Action (Table.States (526), 24, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (526), 25, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (526), 28, 184);
+ Add_Action (Table.States (526), 29, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (526), 30, 8);
+ Add_Action (Table.States (526), 39, 674);
+ Add_Action (Table.States (526), 40, 12);
+ Add_Action (Table.States (526), 46, 14);
+ Add_Action (Table.States (526), 47, 15);
+ Add_Action (Table.States (526), 48, 16);
+ Add_Action (Table.States (526), 49, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (526), 50, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (526), 51, 19);
+ Add_Action (Table.States (526), 63, 25);
+ Add_Action (Table.States (526), 66, 26);
+ Add_Action (Table.States (526), 69, 27);
+ Add_Action (Table.States (526), 71, 28);
+ Add_Action (Table.States (526), 105, 186);
+ Table.States (526).Goto_List.Set_Capacity (54);
+ Add_Goto (Table.States (526), 113, 36);
+ Add_Goto (Table.States (526), 122, 38);
+ Add_Goto (Table.States (526), 128, 41);
+ Add_Goto (Table.States (526), 135, 46);
+ Add_Goto (Table.States (526), 136, 47);
+ Add_Goto (Table.States (526), 158, 392);
+ Add_Goto (Table.States (526), 159, 393);
+ Add_Goto (Table.States (526), 160, 675);
+ Add_Goto (Table.States (526), 180, 55);
+ Add_Goto (Table.States (526), 183, 56);
+ Add_Goto (Table.States (526), 187, 57);
+ Add_Goto (Table.States (526), 194, 59);
+ Add_Goto (Table.States (526), 207, 61);
+ Add_Goto (Table.States (526), 208, 62);
+ Add_Goto (Table.States (526), 210, 63);
+ Add_Goto (Table.States (526), 211, 64);
+ Add_Goto (Table.States (526), 214, 65);
+ Add_Goto (Table.States (526), 215, 66);
+ Add_Goto (Table.States (526), 216, 67);
+ Add_Goto (Table.States (526), 217, 68);
+ Add_Goto (Table.States (526), 220, 70);
+ Add_Goto (Table.States (526), 224, 72);
+ Add_Goto (Table.States (526), 244, 75);
+ Add_Goto (Table.States (526), 245, 76);
+ Add_Goto (Table.States (526), 246, 77);
+ Add_Goto (Table.States (526), 247, 78);
+ Add_Goto (Table.States (526), 248, 79);
+ Add_Goto (Table.States (526), 249, 80);
+ Add_Goto (Table.States (526), 250, 81);
+ Add_Goto (Table.States (526), 251, 82);
+ Add_Goto (Table.States (526), 252, 83);
+ Add_Goto (Table.States (526), 258, 395);
+ Add_Goto (Table.States (526), 260, 85);
+ Add_Goto (Table.States (526), 261, 86);
+ Add_Goto (Table.States (526), 263, 88);
+ Add_Goto (Table.States (526), 264, 89);
+ Add_Goto (Table.States (526), 265, 90);
+ Add_Goto (Table.States (526), 266, 91);
+ Add_Goto (Table.States (526), 267, 676);
+ Add_Goto (Table.States (526), 272, 92);
+ Add_Goto (Table.States (526), 282, 95);
+ Add_Goto (Table.States (526), 290, 96);
+ Add_Goto (Table.States (526), 305, 103);
+ Add_Goto (Table.States (526), 306, 104);
+ Add_Goto (Table.States (526), 308, 106);
+ Add_Goto (Table.States (526), 309, 107);
+ Add_Goto (Table.States (526), 310, 108);
+ Add_Goto (Table.States (526), 312, 109);
+ Add_Goto (Table.States (526), 314, 110);
+ Add_Goto (Table.States (526), 317, 112);
+ Add_Goto (Table.States (526), 318, 113);
+ Add_Goto (Table.States (526), 320, 114);
+ Add_Goto (Table.States (526), 326, 116);
+ Add_Goto (Table.States (526), 332, 117);
+ Table.States (526).Kernel := To_Vector (((305, 35, 5, False),
(305, 35, 2, False)));
+ Table.States (526).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 160, 0)));
+ Table.States (527).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (527), 97, 677);
+ Table.States (527).Kernel := To_Vector ((0 => (277, 193, 1,
False)));
+ Table.States (527).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 677)));
+ Table.States (528).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (528), 97, 678);
+ Table.States (528).Kernel := To_Vector ((0 => (291, 5, 1, False)));
+ Table.States (528).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 678)));
+ Table.States (529).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (529), 7, Reduce, (155, 1), 0, null,
null);
+ Add_Action (Table.States (529), 16, 572);
+ Add_Action (Table.States (529), 21, Reduce, (155, 1), 0, null,
null);
+ Add_Action (Table.States (529), 40, Reduce, (155, 1), 0, null,
null);
+ Add_Action (Table.States (529), 79, Reduce, (155, 1), 0, null,
null);
+ Add_Action (Table.States (529), 83, Reduce, (155, 1), 0, null,
null);
+ Add_Action (Table.States (529), 97, Reduce, (155, 1), 0, null,
null);
+ Add_Action (Table.States (529), 105, Reduce, (155, 1), 0, null,
null);
+ Add_Action (Table.States (529), 106, Reduce, (155, 1), 0, null,
null);
+ Add_Action (Table.States (529), 107, Reduce, (155, 1), 0, null,
null);
+ Table.States (529).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (529), 155, 679);
+ Table.States (529).Kernel := To_Vector (((195, 119, 2, False),
(195, 119, 1, False)));
+ Table.States (529).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 155, 0)));
+ Table.States (530).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (530), 24, 680);
+ Table.States (530).Kernel := To_Vector ((0 => (197, 219, 3,
False)));
+ Table.States (530).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 680)));
+ Table.States (531).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (531), 29, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (531), 40, 12);
+ Add_Action (Table.States (531), 46, 14);
+ Add_Action (Table.States (531), 47, 681);
+ Add_Action (Table.States (531), 50, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (531), 51, 682);
+ Add_Action (Table.States (531), 66, 683);
+ Table.States (531).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (531), 208, 62);
+ Add_Goto (Table.States (531), 247, 684);
+ Add_Goto (Table.States (531), 248, 79);
+ Add_Goto (Table.States (531), 263, 88);
+ Add_Goto (Table.States (531), 264, 685);
+ Add_Goto (Table.States (531), 265, 90);
+ Add_Goto (Table.States (531), 308, 106);
+ Add_Goto (Table.States (531), 317, 112);
+ Table.States (531).Kernel := To_Vector ((0 => (316, 77, 6,
False)));
+ Table.States (531).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 247, 0)));
+ Table.States (532).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (532), 4, 1);
+ Add_Action (Table.States (532), 18, 4);
+ Add_Action (Table.States (532), 67, 686);
+ Table.States (532).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (532), 114, 687);
+ Add_Goto (Table.States (532), 161, 688);
+ Add_Goto (Table.States (532), 162, 537);
+ Table.States (532).Kernel := To_Vector (((296, 88, 3, False),
(296, 88, 2, False), (296, 88, 2, False)));
+ Table.States (532).Minimal_Complete_Actions := To_Vector (((Shift,
67, 686), (Shift, 18, 4)));
+ Table.States (533).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (533), (13, 17, 28, 37, 73), (132, 0), 2,
block_label_0'Access,
block_label_0_check'Access);
- Table.States (529).Kernel := To_Vector ((0 => (131, 81, 0,
False)));
- Table.States (529).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 131, 2)));
- Table.States (530).Action_List.Set_Capacity (29);
- Add_Action (Table.States (530), (4, 5, 13, 15, 17, 18, 22, 23, 24,
26, 27, 28, 31, 32, 37, 41, 43, 48, 52,
- 57, 58, 61, 68, 72, 73, 93, 104, 105, 106), (299, 0), 2, null,
null);
- Table.States (530).Kernel := To_Vector ((0 => (299, 306, 0,
True)));
- Table.States (530).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 299, 2)));
- Table.States (530).Minimal_Complete_Actions_Recursive := True;
- Table.States (531).Action_List.Set_Capacity (1);
- Add_Action (Table.States (531), 24, 683);
- Table.States (531).Kernel := To_Vector ((0 => (152, 300, 3,
False)));
- Table.States (531).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 683)));
- Table.States (532).Action_List.Set_Capacity (1);
- Add_Action (Table.States (532), 24, 684);
- Table.States (532).Kernel := To_Vector ((0 => (323, 160, 3,
False)));
- Table.States (532).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 684)));
- Table.States (533).Action_List.Set_Capacity (25);
- Add_Action (Table.States (533), 4, 1);
- Add_Action (Table.States (533), 5, 2);
- Add_Action (Table.States (533), 13, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (533), 15, 3);
- Add_Action (Table.States (533), 17, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (533), 18, 4);
- Add_Action (Table.States (533), 22, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (533), 24, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (533), 27, 5);
- Add_Action (Table.States (533), 28, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (533), 31, 9);
- Add_Action (Table.States (533), 32, 10);
- Add_Action (Table.States (533), 37, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (533), 41, 13);
- Add_Action (Table.States (533), 43, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (533), 48, 16);
- Add_Action (Table.States (533), 52, 20);
- Add_Action (Table.States (533), 57, 21);
- Add_Action (Table.States (533), 58, 22);
- Add_Action (Table.States (533), 61, 24);
- Add_Action (Table.States (533), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (533), 93, 31);
- Add_Action (Table.States (533), 104, 360);
- Add_Action (Table.States (533), 105, 33);
- Add_Action (Table.States (533), 106, 34);
- Table.States (533).Goto_List.Set_Capacity (31);
- Add_Goto (Table.States (533), 113, 36);
- Add_Goto (Table.States (533), 123, 38);
- Add_Goto (Table.States (533), 126, 39);
- Add_Goto (Table.States (533), 128, 41);
- Add_Goto (Table.States (533), 131, 42);
- Add_Goto (Table.States (533), 132, 43);
- Add_Goto (Table.States (533), 133, 44);
- Add_Goto (Table.States (533), 139, 47);
- Add_Goto (Table.States (533), 151, 50);
- Add_Goto (Table.States (533), 152, 51);
- Add_Goto (Table.States (533), 161, 53);
- Add_Goto (Table.States (533), 190, 57);
- Add_Goto (Table.States (533), 196, 59);
- Add_Goto (Table.States (533), 217, 68);
- Add_Goto (Table.States (533), 222, 70);
- Add_Goto (Table.States (533), 232, 72);
- Add_Goto (Table.States (533), 239, 73);
- Add_Goto (Table.States (533), 257, 83);
- Add_Goto (Table.States (533), 261, 86);
- Add_Goto (Table.States (533), 272, 92);
- Add_Goto (Table.States (533), 276, 93);
- Add_Goto (Table.States (533), 290, 96);
- Add_Goto (Table.States (533), 293, 97);
- Add_Goto (Table.States (533), 294, 98);
- Add_Goto (Table.States (533), 298, 99);
- Add_Goto (Table.States (533), 299, 361);
- Add_Goto (Table.States (533), 300, 685);
- Add_Goto (Table.States (533), 302, 100);
- Add_Goto (Table.States (533), 303, 101);
- Add_Goto (Table.States (533), 306, 363);
- Add_Goto (Table.States (533), 323, 114);
- Table.States (533).Kernel := To_Vector ((0 => (160, 161, 0,
False)));
- Table.States (533).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 300, 0)));
- Table.States (534).Action_List.Set_Capacity (3);
- Add_Action (Table.States (534), (22, 24, 43), (296, 0), 3,
select_alternative_list_0'Access, null);
- Table.States (534).Kernel := To_Vector ((0 => (296, 295, 0,
True)));
- Table.States (534).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 296, 3)));
+ Table.States (533).Kernel := To_Vector ((0 => (132, 82, 0,
False)));
+ Table.States (533).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 132, 2)));
+ Table.States (534).Action_List.Set_Capacity (30);
+ Add_Action (Table.States (534), (4, 5, 13, 15, 17, 18, 22, 23, 24,
26, 27, 28, 31, 32, 37, 41, 43, 48, 52,
+ 57, 58, 61, 68, 72, 73, 79, 94, 105, 106, 107), (300, 0), 2, null,
null);
+ Table.States (534).Kernel := To_Vector ((0 => (300, 307, 0,
True)));
+ Table.States (534).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 300, 2)));
Table.States (534).Minimal_Complete_Actions_Recursive := True;
Table.States (535).Action_List.Set_Capacity (1);
- Add_Action (Table.States (535), 24, 686);
- Table.States (535).Kernel := To_Vector ((0 => (294, 300, 3,
False)));
- Table.States (535).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 686)));
+ Add_Action (Table.States (535), 24, 689);
+ Table.States (535).Kernel := To_Vector ((0 => (153, 301, 3,
False)));
+ Table.States (535).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 689)));
Table.States (536).Action_List.Set_Capacity (1);
- Add_Action (Table.States (536), 96, 687);
- Table.States (536).Kernel := To_Vector ((0 => (294, 61, 1,
False)));
- Table.States (536).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 687)));
- Table.States (537).Action_List.Set_Capacity (23);
+ Add_Action (Table.States (536), 24, 690);
+ Table.States (536).Kernel := To_Vector ((0 => (324, 161, 3,
False)));
+ Table.States (536).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 690)));
+ Table.States (537).Action_List.Set_Capacity (26);
Add_Action (Table.States (537), 4, 1);
Add_Action (Table.States (537), 5, 2);
- Add_Action (Table.States (537), 13, Reduce, (132, 1), 0, null,
null);
+ Add_Action (Table.States (537), 13, Reduce, (133, 1), 0, null,
null);
Add_Action (Table.States (537), 15, 3);
- Add_Action (Table.States (537), 17, Reduce, (132, 1), 0, null,
null);
+ Add_Action (Table.States (537), 17, Reduce, (133, 1), 0, null,
null);
Add_Action (Table.States (537), 18, 4);
- Add_Action (Table.States (537), 24, Reduce, (300, 1), 0, null,
null);
+ Add_Action (Table.States (537), 22, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (537), 24, Reduce, (301, 1), 0, null,
null);
Add_Action (Table.States (537), 27, 5);
- Add_Action (Table.States (537), 28, Reduce, (132, 1), 0, null,
null);
+ Add_Action (Table.States (537), 28, Reduce, (133, 1), 0, null,
null);
Add_Action (Table.States (537), 31, 9);
Add_Action (Table.States (537), 32, 10);
- Add_Action (Table.States (537), 37, Reduce, (132, 1), 0, null,
null);
+ Add_Action (Table.States (537), 37, Reduce, (133, 1), 0, null,
null);
Add_Action (Table.States (537), 41, 13);
+ Add_Action (Table.States (537), 43, Reduce, (301, 1), 0, null,
null);
Add_Action (Table.States (537), 48, 16);
Add_Action (Table.States (537), 52, 20);
Add_Action (Table.States (537), 57, 21);
Add_Action (Table.States (537), 58, 22);
Add_Action (Table.States (537), 61, 24);
- Add_Action (Table.States (537), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (537), 93, 31);
- Add_Action (Table.States (537), 104, 360);
- Add_Action (Table.States (537), 105, 33);
+ Add_Action (Table.States (537), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (537), 79, 31);
+ Add_Action (Table.States (537), 94, 32);
+ Add_Action (Table.States (537), 105, 361);
Add_Action (Table.States (537), 106, 34);
+ Add_Action (Table.States (537), 107, 35);
Table.States (537).Goto_List.Set_Capacity (31);
- Add_Goto (Table.States (537), 113, 36);
- Add_Goto (Table.States (537), 123, 38);
- Add_Goto (Table.States (537), 126, 39);
- Add_Goto (Table.States (537), 128, 41);
- Add_Goto (Table.States (537), 131, 42);
+ Add_Goto (Table.States (537), 114, 37);
+ Add_Goto (Table.States (537), 124, 39);
+ Add_Goto (Table.States (537), 127, 40);
+ Add_Goto (Table.States (537), 129, 42);
Add_Goto (Table.States (537), 132, 43);
Add_Goto (Table.States (537), 133, 44);
- Add_Goto (Table.States (537), 139, 47);
- Add_Goto (Table.States (537), 151, 50);
+ Add_Goto (Table.States (537), 134, 45);
+ Add_Goto (Table.States (537), 140, 48);
Add_Goto (Table.States (537), 152, 51);
- Add_Goto (Table.States (537), 161, 53);
- Add_Goto (Table.States (537), 190, 57);
- Add_Goto (Table.States (537), 196, 59);
- Add_Goto (Table.States (537), 217, 68);
- Add_Goto (Table.States (537), 222, 70);
- Add_Goto (Table.States (537), 232, 72);
- Add_Goto (Table.States (537), 239, 73);
- Add_Goto (Table.States (537), 257, 83);
- Add_Goto (Table.States (537), 261, 86);
- Add_Goto (Table.States (537), 272, 92);
- Add_Goto (Table.States (537), 276, 93);
- Add_Goto (Table.States (537), 290, 96);
- Add_Goto (Table.States (537), 293, 97);
+ Add_Goto (Table.States (537), 153, 52);
+ Add_Goto (Table.States (537), 162, 54);
+ Add_Goto (Table.States (537), 191, 58);
+ Add_Goto (Table.States (537), 197, 60);
+ Add_Goto (Table.States (537), 218, 69);
+ Add_Goto (Table.States (537), 223, 71);
+ Add_Goto (Table.States (537), 233, 73);
+ Add_Goto (Table.States (537), 240, 74);
+ Add_Goto (Table.States (537), 258, 84);
+ Add_Goto (Table.States (537), 262, 87);
+ Add_Goto (Table.States (537), 273, 93);
+ Add_Goto (Table.States (537), 277, 94);
+ Add_Goto (Table.States (537), 291, 97);
Add_Goto (Table.States (537), 294, 98);
- Add_Goto (Table.States (537), 298, 99);
- Add_Goto (Table.States (537), 299, 361);
- Add_Goto (Table.States (537), 300, 688);
- Add_Goto (Table.States (537), 302, 100);
+ Add_Goto (Table.States (537), 295, 99);
+ Add_Goto (Table.States (537), 299, 100);
+ Add_Goto (Table.States (537), 300, 362);
+ Add_Goto (Table.States (537), 301, 691);
Add_Goto (Table.States (537), 303, 101);
- Add_Goto (Table.States (537), 306, 363);
- Add_Goto (Table.States (537), 323, 114);
- Table.States (537).Kernel := To_Vector ((0 => (126, 5, 3, False)));
- Table.States (537).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 300, 0)));
- Table.States (538).Action_List.Set_Capacity (2);
- Add_Action (Table.States (538), 74, 337);
- Add_Action (Table.States (538), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (538).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (538), 122, 689);
- Table.States (538).Kernel := To_Vector ((0 => (313, 314, 1,
False)));
- Table.States (538).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
+ Add_Goto (Table.States (537), 304, 102);
+ Add_Goto (Table.States (537), 307, 364);
+ Add_Goto (Table.States (537), 324, 115);
+ Table.States (537).Kernel := To_Vector ((0 => (161, 162, 0,
False)));
+ Table.States (537).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 301, 0)));
+ end Subr_10;
+ procedure Subr_11
+ is begin
+ Table.States (538).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (538), (22, 24, 43), (297, 0), 3,
select_alternative_list_0'Access, null);
+ Table.States (538).Kernel := To_Vector ((0 => (297, 296, 0,
True)));
+ Table.States (538).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 297, 3)));
+ Table.States (538).Minimal_Complete_Actions_Recursive := True;
Table.States (539).Action_List.Set_Capacity (1);
- Add_Action (Table.States (539), 60, 690);
- Table.States (539).Kernel := To_Vector ((0 => (317, 35, 2,
False)));
- Table.States (539).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 60, 690)));
+ Add_Action (Table.States (539), 24, 692);
+ Table.States (539).Kernel := To_Vector ((0 => (295, 301, 3,
False)));
+ Table.States (539).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 692)));
Table.States (540).Action_List.Set_Capacity (1);
- Add_Action (Table.States (540), 35, 691);
- Table.States (540).Kernel := To_Vector ((0 => (316, 122, 4,
False)));
- Table.States (540).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 691)));
- Table.States (541).Action_List.Set_Capacity (3);
- Add_Action (Table.States (541), 35, Reduce, (122, 1), 0, null,
null);
- Add_Action (Table.States (541), 74, 337);
- Add_Action (Table.States (541), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (541).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (541), 122, 692);
- Table.States (541).Kernel := To_Vector (((319, 169, 6, False),
(319, 169, 3, False), (319, 169, 1,
+ Add_Action (Table.States (540), 97, 693);
+ Table.States (540).Kernel := To_Vector ((0 => (295, 61, 1,
False)));
+ Table.States (540).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 693)));
+ Table.States (541).Action_List.Set_Capacity (24);
+ Add_Action (Table.States (541), 4, 1);
+ Add_Action (Table.States (541), 5, 2);
+ Add_Action (Table.States (541), 13, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (541), 15, 3);
+ Add_Action (Table.States (541), 17, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (541), 18, 4);
+ Add_Action (Table.States (541), 24, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (541), 27, 5);
+ Add_Action (Table.States (541), 28, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (541), 31, 9);
+ Add_Action (Table.States (541), 32, 10);
+ Add_Action (Table.States (541), 37, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (541), 41, 13);
+ Add_Action (Table.States (541), 48, 16);
+ Add_Action (Table.States (541), 52, 20);
+ Add_Action (Table.States (541), 57, 21);
+ Add_Action (Table.States (541), 58, 22);
+ Add_Action (Table.States (541), 61, 24);
+ Add_Action (Table.States (541), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (541), 79, 31);
+ Add_Action (Table.States (541), 94, 32);
+ Add_Action (Table.States (541), 105, 361);
+ Add_Action (Table.States (541), 106, 34);
+ Add_Action (Table.States (541), 107, 35);
+ Table.States (541).Goto_List.Set_Capacity (31);
+ Add_Goto (Table.States (541), 114, 37);
+ Add_Goto (Table.States (541), 124, 39);
+ Add_Goto (Table.States (541), 127, 40);
+ Add_Goto (Table.States (541), 129, 42);
+ Add_Goto (Table.States (541), 132, 43);
+ Add_Goto (Table.States (541), 133, 44);
+ Add_Goto (Table.States (541), 134, 45);
+ Add_Goto (Table.States (541), 140, 48);
+ Add_Goto (Table.States (541), 152, 51);
+ Add_Goto (Table.States (541), 153, 52);
+ Add_Goto (Table.States (541), 162, 54);
+ Add_Goto (Table.States (541), 191, 58);
+ Add_Goto (Table.States (541), 197, 60);
+ Add_Goto (Table.States (541), 218, 69);
+ Add_Goto (Table.States (541), 223, 71);
+ Add_Goto (Table.States (541), 233, 73);
+ Add_Goto (Table.States (541), 240, 74);
+ Add_Goto (Table.States (541), 258, 84);
+ Add_Goto (Table.States (541), 262, 87);
+ Add_Goto (Table.States (541), 273, 93);
+ Add_Goto (Table.States (541), 277, 94);
+ Add_Goto (Table.States (541), 291, 97);
+ Add_Goto (Table.States (541), 294, 98);
+ Add_Goto (Table.States (541), 295, 99);
+ Add_Goto (Table.States (541), 299, 100);
+ Add_Goto (Table.States (541), 300, 362);
+ Add_Goto (Table.States (541), 301, 694);
+ Add_Goto (Table.States (541), 303, 101);
+ Add_Goto (Table.States (541), 304, 102);
+ Add_Goto (Table.States (541), 307, 364);
+ Add_Goto (Table.States (541), 324, 115);
+ Table.States (541).Kernel := To_Vector ((0 => (127, 5, 3, False)));
+ Table.States (541).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 301, 0)));
+ Table.States (542).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (542), 74, 338);
+ Add_Action (Table.States (542), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (542).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (542), 123, 695);
+ Table.States (542).Kernel := To_Vector ((0 => (314, 315, 1,
False)));
+ Table.States (542).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (543).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (543), 60, 696);
+ Table.States (543).Kernel := To_Vector ((0 => (318, 35, 2,
False)));
+ Table.States (543).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 60, 696)));
+ Table.States (544).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (544), 35, 697);
+ Table.States (544).Kernel := To_Vector ((0 => (317, 123, 4,
False)));
+ Table.States (544).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 697)));
+ Table.States (545).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (545), 35, Reduce, (123, 1), 0, null,
null);
+ Add_Action (Table.States (545), 74, 338);
+ Add_Action (Table.States (545), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (545).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (545), 123, 698);
+ Table.States (545).Kernel := To_Vector (((320, 170, 6, False),
(320, 170, 3, False), (320, 170, 1,
False)));
- Table.States (541).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (542).Action_List.Set_Capacity (18);
- Add_Action (Table.States (542), 24, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (542), 25, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (542), 28, 183);
- Add_Action (Table.States (542), 29, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (542), 30, 8);
- Add_Action (Table.States (542), 39, 693);
- Add_Action (Table.States (542), 40, 12);
- Add_Action (Table.States (542), 46, 14);
- Add_Action (Table.States (542), 47, 15);
- Add_Action (Table.States (542), 48, 16);
- Add_Action (Table.States (542), 49, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (542), 50, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (542), 51, 19);
- Add_Action (Table.States (542), 63, 25);
- Add_Action (Table.States (542), 66, 26);
- Add_Action (Table.States (542), 69, 27);
- Add_Action (Table.States (542), 71, 28);
- Add_Action (Table.States (542), 104, 185);
- Table.States (542).Goto_List.Set_Capacity (54);
- Add_Goto (Table.States (542), 112, 35);
- Add_Goto (Table.States (542), 121, 37);
- Add_Goto (Table.States (542), 127, 40);
- Add_Goto (Table.States (542), 134, 45);
- Add_Goto (Table.States (542), 135, 46);
- Add_Goto (Table.States (542), 157, 391);
- Add_Goto (Table.States (542), 158, 392);
- Add_Goto (Table.States (542), 159, 694);
- Add_Goto (Table.States (542), 179, 54);
- Add_Goto (Table.States (542), 182, 55);
- Add_Goto (Table.States (542), 186, 56);
- Add_Goto (Table.States (542), 193, 58);
- Add_Goto (Table.States (542), 206, 60);
- Add_Goto (Table.States (542), 207, 61);
- Add_Goto (Table.States (542), 209, 62);
- Add_Goto (Table.States (542), 210, 63);
- Add_Goto (Table.States (542), 213, 64);
- Add_Goto (Table.States (542), 214, 65);
- Add_Goto (Table.States (542), 215, 66);
- Add_Goto (Table.States (542), 216, 67);
- Add_Goto (Table.States (542), 219, 69);
- Add_Goto (Table.States (542), 223, 71);
- Add_Goto (Table.States (542), 243, 74);
- Add_Goto (Table.States (542), 244, 75);
- Add_Goto (Table.States (542), 245, 76);
- Add_Goto (Table.States (542), 246, 77);
- Add_Goto (Table.States (542), 247, 78);
- Add_Goto (Table.States (542), 248, 79);
- Add_Goto (Table.States (542), 249, 80);
- Add_Goto (Table.States (542), 250, 81);
- Add_Goto (Table.States (542), 251, 82);
- Add_Goto (Table.States (542), 257, 394);
- Add_Goto (Table.States (542), 259, 84);
- Add_Goto (Table.States (542), 260, 85);
- Add_Goto (Table.States (542), 262, 87);
- Add_Goto (Table.States (542), 263, 88);
- Add_Goto (Table.States (542), 264, 89);
- Add_Goto (Table.States (542), 265, 90);
- Add_Goto (Table.States (542), 271, 91);
- Add_Goto (Table.States (542), 281, 94);
- Add_Goto (Table.States (542), 289, 95);
- Add_Goto (Table.States (542), 304, 102);
- Add_Goto (Table.States (542), 305, 103);
- Add_Goto (Table.States (542), 307, 105);
- Add_Goto (Table.States (542), 308, 106);
- Add_Goto (Table.States (542), 309, 107);
- Add_Goto (Table.States (542), 311, 108);
- Add_Goto (Table.States (542), 313, 109);
- Add_Goto (Table.States (542), 316, 111);
- Add_Goto (Table.States (542), 317, 112);
- Add_Goto (Table.States (542), 318, 695);
- Add_Goto (Table.States (542), 319, 113);
- Add_Goto (Table.States (542), 325, 115);
- Add_Goto (Table.States (542), 331, 116);
- Table.States (542).Kernel := To_Vector (((305, 35, 5, False),
(305, 35, 2, False)));
- Table.States (542).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 318, 0)));
- Table.States (543).Action_List.Set_Capacity (40);
- Add_Action (Table.States (543), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (305, 2), 4,
+ Table.States (545).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (546).Action_List.Set_Capacity (18);
+ Add_Action (Table.States (546), 24, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (546), 25, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (546), 28, 184);
+ Add_Action (Table.States (546), 29, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (546), 30, 8);
+ Add_Action (Table.States (546), 39, 699);
+ Add_Action (Table.States (546), 40, 12);
+ Add_Action (Table.States (546), 46, 14);
+ Add_Action (Table.States (546), 47, 15);
+ Add_Action (Table.States (546), 48, 16);
+ Add_Action (Table.States (546), 49, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (546), 50, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (546), 51, 19);
+ Add_Action (Table.States (546), 63, 25);
+ Add_Action (Table.States (546), 66, 26);
+ Add_Action (Table.States (546), 69, 27);
+ Add_Action (Table.States (546), 71, 28);
+ Add_Action (Table.States (546), 105, 186);
+ Table.States (546).Goto_List.Set_Capacity (54);
+ Add_Goto (Table.States (546), 113, 36);
+ Add_Goto (Table.States (546), 122, 38);
+ Add_Goto (Table.States (546), 128, 41);
+ Add_Goto (Table.States (546), 135, 46);
+ Add_Goto (Table.States (546), 136, 47);
+ Add_Goto (Table.States (546), 158, 392);
+ Add_Goto (Table.States (546), 159, 393);
+ Add_Goto (Table.States (546), 160, 700);
+ Add_Goto (Table.States (546), 180, 55);
+ Add_Goto (Table.States (546), 183, 56);
+ Add_Goto (Table.States (546), 187, 57);
+ Add_Goto (Table.States (546), 194, 59);
+ Add_Goto (Table.States (546), 207, 61);
+ Add_Goto (Table.States (546), 208, 62);
+ Add_Goto (Table.States (546), 210, 63);
+ Add_Goto (Table.States (546), 211, 64);
+ Add_Goto (Table.States (546), 214, 65);
+ Add_Goto (Table.States (546), 215, 66);
+ Add_Goto (Table.States (546), 216, 67);
+ Add_Goto (Table.States (546), 217, 68);
+ Add_Goto (Table.States (546), 220, 70);
+ Add_Goto (Table.States (546), 224, 72);
+ Add_Goto (Table.States (546), 244, 75);
+ Add_Goto (Table.States (546), 245, 76);
+ Add_Goto (Table.States (546), 246, 77);
+ Add_Goto (Table.States (546), 247, 78);
+ Add_Goto (Table.States (546), 248, 79);
+ Add_Goto (Table.States (546), 249, 80);
+ Add_Goto (Table.States (546), 250, 81);
+ Add_Goto (Table.States (546), 251, 82);
+ Add_Goto (Table.States (546), 252, 83);
+ Add_Goto (Table.States (546), 258, 395);
+ Add_Goto (Table.States (546), 260, 85);
+ Add_Goto (Table.States (546), 261, 86);
+ Add_Goto (Table.States (546), 263, 88);
+ Add_Goto (Table.States (546), 264, 89);
+ Add_Goto (Table.States (546), 265, 90);
+ Add_Goto (Table.States (546), 266, 91);
+ Add_Goto (Table.States (546), 272, 92);
+ Add_Goto (Table.States (546), 282, 95);
+ Add_Goto (Table.States (546), 290, 96);
+ Add_Goto (Table.States (546), 305, 103);
+ Add_Goto (Table.States (546), 306, 104);
+ Add_Goto (Table.States (546), 308, 106);
+ Add_Goto (Table.States (546), 309, 107);
+ Add_Goto (Table.States (546), 310, 108);
+ Add_Goto (Table.States (546), 312, 109);
+ Add_Goto (Table.States (546), 314, 110);
+ Add_Goto (Table.States (546), 317, 112);
+ Add_Goto (Table.States (546), 318, 113);
+ Add_Goto (Table.States (546), 319, 701);
+ Add_Goto (Table.States (546), 320, 114);
+ Add_Goto (Table.States (546), 326, 116);
+ Add_Goto (Table.States (546), 332, 117);
+ Table.States (546).Kernel := To_Vector (((306, 35, 5, False),
(306, 35, 2, False)));
+ Table.States (546).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 319, 0)));
+ Table.States (547).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (547), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (306, 2), 4,
single_task_declaration_2'Access, null);
- Table.States (543).Kernel := To_Vector ((0 => (305, 96, 0,
False)));
- Table.States (543).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 305, 4)));
- Table.States (544).Action_List.Set_Capacity (1);
- Add_Action (Table.States (544), 77, 696);
- Table.States (544).Kernel := To_Vector ((0 => (169, 80, 1,
False)));
- Table.States (544).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 696)));
- Table.States (545).Action_List.Set_Capacity (2);
- Add_Action (Table.States (545), (77, 96), (171, 1), 1, null, null);
- Table.States (545).Kernel := To_Vector ((0 => (171, 170, 0,
False)));
- Table.States (545).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 171, 1)));
- Table.States (546).Action_List.Set_Capacity (2);
- Add_Action (Table.States (546), 77, 697);
- Add_Action (Table.States (546), 96, 698);
- Table.States (546).Kernel := To_Vector (((169, 171, 1, False),
(171, 171, 1, True)));
- Table.States (546).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 697)));
- Table.States (547).Action_List.Set_Capacity (2);
- Add_Action (Table.States (547), 81, 699);
- Add_Action (Table.States (547), 83, 234);
- Table.States (547).Kernel := To_Vector (((170, 219, 3, False),
(170, 219, 4, False), (170, 219, 2, False),
- (170, 219, 3, False), (219, 219, 2, True)));
- Table.States (547).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 81, 699)));
- Table.States (548).Action_List.Set_Capacity (19);
- Add_Action (Table.States (548), 6, 700);
- Add_Action (Table.States (548), 7, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (548), 11, 701);
- Add_Action (Table.States (548), 19, 702);
- Add_Action (Table.States (548), 20, 703);
- Add_Action (Table.States (548), 34, 704);
- Add_Action (Table.States (548), 36, 705);
- Add_Action (Table.States (548), 38, 706);
- Add_Action (Table.States (548), 39, Reduce, (109, 5), 0, null,
null);
- Add_Conflict (Table.States (548), 39, (110, 3), 0, null, null);
- Add_Action (Table.States (548), 40, 386);
- Add_Action (Table.States (548), 41, Reduce, (111, 5), 0, null,
null);
- Add_Action (Table.States (548), 49, Reduce, (111, 5), 0, null,
null);
- Add_Action (Table.States (548), 51, 708);
- Add_Action (Table.States (548), 53, 709);
- Add_Action (Table.States (548), 54, Reduce, (111, 5), 0, null,
null);
- Add_Action (Table.States (548), 64, 711);
- Add_Action (Table.States (548), 65, 712);
- Add_Action (Table.States (548), 66, 713);
- Add_Action (Table.States (548), 76, 714);
- Table.States (548).Goto_List.Set_Capacity (10);
- Add_Goto (Table.States (548), 109, 715);
- Add_Goto (Table.States (548), 110, 716);
- Add_Goto (Table.States (548), 111, 717);
- Add_Goto (Table.States (548), 114, 718);
- Add_Goto (Table.States (548), 120, 719);
- Add_Goto (Table.States (548), 162, 720);
- Add_Goto (Table.States (548), 183, 721);
- Add_Goto (Table.States (548), 228, 722);
- Add_Goto (Table.States (548), 241, 723);
- Add_Goto (Table.States (548), 326, 724);
- Table.States (548).Kernel := To_Vector (((206, 35, 2, False),
(223, 35, 2, False), (259, 35, 5, False),
- (260, 35, 2, False)));
- Table.States (548).Minimal_Complete_Actions := To_Vector (((Shift,
38, 706), (Shift, 65, 712), (Reduce,
- 111, 0)));
- Table.States (549).Action_List.Set_Capacity (40);
- Add_Action (Table.States (549), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (223, 1), 4,
- incomplete_type_declaration_1'Access, null);
- Table.States (549).Kernel := To_Vector ((0 => (223, 96, 0,
False)));
- Table.States (549).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 223, 4)));
+ Table.States (547).Kernel := To_Vector ((0 => (306, 97, 0,
False)));
+ Table.States (547).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 306, 4)));
+ Table.States (548).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (548), 77, 702);
+ Table.States (548).Kernel := To_Vector ((0 => (170, 81, 1,
False)));
+ Table.States (548).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 702)));
+ Table.States (549).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (549), (77, 97), (172, 1), 1, null, null);
+ Table.States (549).Kernel := To_Vector ((0 => (172, 171, 0,
False)));
+ Table.States (549).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 172, 1)));
Table.States (550).Action_List.Set_Capacity (2);
- Add_Action (Table.States (550), 83, 381);
- Add_Action (Table.States (550), 96, 725);
- Table.States (550).Kernel := To_Vector (((238, 238, 2, True),
(331, 238, 1, False)));
- Table.States (550).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 725)));
- Table.States (551).Action_List.Set_Capacity (40);
- Add_Action (Table.States (551), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (331, 1), 4,
+ Add_Action (Table.States (550), 77, 703);
+ Add_Action (Table.States (550), 97, 704);
+ Table.States (550).Kernel := To_Vector (((170, 172, 1, False),
(172, 172, 1, True)));
+ Table.States (550).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 703)));
+ Table.States (551).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (551), 82, 705);
+ Add_Action (Table.States (551), 84, 235);
+ Table.States (551).Kernel := To_Vector (((171, 220, 3, False),
(171, 220, 4, False), (171, 220, 2, False),
+ (171, 220, 3, False), (220, 220, 2, True)));
+ Table.States (551).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 82, 705)));
+ Table.States (552).Action_List.Set_Capacity (19);
+ Add_Action (Table.States (552), 6, 706);
+ Add_Action (Table.States (552), 7, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (552), 11, 707);
+ Add_Action (Table.States (552), 19, 708);
+ Add_Action (Table.States (552), 20, 709);
+ Add_Action (Table.States (552), 34, 710);
+ Add_Action (Table.States (552), 36, 711);
+ Add_Action (Table.States (552), 38, 712);
+ Add_Action (Table.States (552), 39, Reduce, (110, 5), 0, null,
null);
+ Add_Conflict (Table.States (552), 39, (111, 3), 0, null, null);
+ Add_Action (Table.States (552), 40, 387);
+ Add_Action (Table.States (552), 41, Reduce, (112, 5), 0, null,
null);
+ Add_Action (Table.States (552), 49, Reduce, (112, 5), 0, null,
null);
+ Add_Action (Table.States (552), 51, 714);
+ Add_Action (Table.States (552), 53, 715);
+ Add_Action (Table.States (552), 54, Reduce, (112, 5), 0, null,
null);
+ Add_Action (Table.States (552), 64, 717);
+ Add_Action (Table.States (552), 65, 718);
+ Add_Action (Table.States (552), 66, 719);
+ Add_Action (Table.States (552), 76, 720);
+ Table.States (552).Goto_List.Set_Capacity (10);
+ Add_Goto (Table.States (552), 110, 721);
+ Add_Goto (Table.States (552), 111, 722);
+ Add_Goto (Table.States (552), 112, 723);
+ Add_Goto (Table.States (552), 115, 724);
+ Add_Goto (Table.States (552), 121, 725);
+ Add_Goto (Table.States (552), 163, 726);
+ Add_Goto (Table.States (552), 184, 727);
+ Add_Goto (Table.States (552), 229, 728);
+ Add_Goto (Table.States (552), 242, 729);
+ Add_Goto (Table.States (552), 327, 730);
+ Table.States (552).Kernel := To_Vector (((207, 35, 2, False),
(224, 35, 2, False), (260, 35, 5, False),
+ (261, 35, 2, False)));
+ Table.States (552).Minimal_Complete_Actions := To_Vector (((Shift,
38, 712), (Shift, 65, 718), (Reduce,
+ 112, 0)));
+ Table.States (553).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (553), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (224, 1), 4,
+ incomplete_type_declaration_1'Access, null);
+ Table.States (553).Kernel := To_Vector ((0 => (224, 97, 0,
False)));
+ Table.States (553).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 224, 4)));
+ Table.States (554).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (554), 84, 382);
+ Add_Action (Table.States (554), 97, 731);
+ Table.States (554).Kernel := To_Vector (((239, 239, 2, True),
(332, 239, 1, False)));
+ Table.States (554).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 731)));
+ Table.States (555).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (555), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (332, 1), 4,
use_clause_1'Access, null);
- Table.States (551).Kernel := To_Vector ((0 => (331, 96, 0,
False)));
- Table.States (551).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 331, 4)));
- Table.States (552).Action_List.Set_Capacity (6);
- Add_Action (Table.States (552), 76, 235);
- Add_Action (Table.States (552), 83, Reduce, (238, 0), 3, null,
null);
- Add_Action (Table.States (552), 84, 237);
- Add_Action (Table.States (552), 96, Reduce, (238, 0), 3, null,
null);
- Add_Action (Table.States (552), 101, 239);
- Add_Action (Table.States (552), 102, 240);
- Table.States (552).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (552), 115, 241);
- Add_Goto (Table.States (552), 322, 242);
- Table.States (552).Kernel := To_Vector (((128, 239, 2, True),
(238, 239, 0, True), (239, 239, 5, True),
- (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (552).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 238, 3)));
- Table.States (552).Minimal_Complete_Actions_Recursive := True;
- end Subr_10;
- procedure Subr_11
- is begin
- Table.States (553).Action_List.Set_Capacity (3);
- Add_Action (Table.States (553), 104, 119);
- Add_Action (Table.States (553), 105, 33);
- Add_Action (Table.States (553), 106, 34);
- Table.States (553).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (553), 128, 41);
- Add_Goto (Table.States (553), 239, 726);
- Add_Goto (Table.States (553), 272, 92);
- Add_Goto (Table.States (553), 293, 97);
- Table.States (553).Kernel := To_Vector ((0 => (245, 56, 2,
False)));
- Table.States (553).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (554).Action_List.Set_Capacity (11);
- Add_Action (Table.States (554), (7, 21, 35, 56, 74, 77, 82, 96,
104, 105, 106), (241, 0), 2, null, null);
- Table.States (554).Kernel := To_Vector ((0 => (241, 41, 0,
False)));
- Table.States (554).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 241, 2)));
- Table.States (555).Action_List.Set_Capacity (3);
- Add_Action (Table.States (555), 104, 119);
- Add_Action (Table.States (555), 105, 33);
- Add_Action (Table.States (555), 106, 34);
- Table.States (555).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (555), 128, 41);
- Add_Goto (Table.States (555), 239, 727);
- Add_Goto (Table.States (555), 272, 92);
- Add_Goto (Table.States (555), 293, 97);
- Table.States (555).Kernel := To_Vector ((0 => (245, 56, 2,
False)));
- Table.States (555).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (556).Action_List.Set_Capacity (8);
- Add_Action (Table.States (556), 9, 728);
- Add_Action (Table.States (556), 16, 729);
- Add_Action (Table.States (556), 29, Reduce, (270, 1), 0, null,
null);
- Add_Action (Table.States (556), 50, Reduce, (270, 1), 0, null,
null);
- Add_Action (Table.States (556), 51, 730);
- Add_Action (Table.States (556), 104, Reduce, (208, 2), 0, null,
null);
- Add_Action (Table.States (556), 105, Reduce, (208, 2), 0, null,
null);
- Add_Action (Table.States (556), 106, Reduce, (208, 2), 0, null,
null);
+ Table.States (555).Kernel := To_Vector ((0 => (332, 97, 0,
False)));
+ Table.States (555).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 332, 4)));
+ Table.States (556).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (556), 76, 236);
+ Add_Action (Table.States (556), 84, Reduce, (239, 0), 3, null,
null);
+ Add_Action (Table.States (556), 85, 238);
+ Add_Action (Table.States (556), 97, Reduce, (239, 0), 3, null,
null);
+ Add_Action (Table.States (556), 102, 240);
+ Add_Action (Table.States (556), 103, 241);
Table.States (556).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (556), 208, 731);
- Add_Goto (Table.States (556), 270, 732);
- Table.States (556).Kernel := To_Vector (((114, 7, 1, False), (114,
7, 2, True), (114, 7, 1, False)));
- Table.States (556).Minimal_Complete_Actions := To_Vector
(((Reduce, 270, 0), (Reduce, 208, 0)));
+ Add_Goto (Table.States (556), 116, 242);
+ Add_Goto (Table.States (556), 323, 243);
+ Table.States (556).Kernel := To_Vector (((129, 240, 2, True),
(239, 240, 0, True), (240, 240, 5, True),
+ (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (556).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 239, 3)));
Table.States (556).Minimal_Complete_Actions_Recursive := True;
- Table.States (557).Action_List.Set_Capacity (5);
- Add_Action (Table.States (557), 56, 733);
- Add_Action (Table.States (557), 76, 235);
- Add_Action (Table.States (557), 84, 237);
- Add_Action (Table.States (557), 101, 239);
- Add_Action (Table.States (557), 102, 240);
- Table.States (557).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (557), 115, 241);
- Add_Goto (Table.States (557), 322, 242);
- Table.States (557).Kernel := To_Vector (((128, 239, 2, True),
(239, 239, 5, True), (239, 239, 2, True),
- (245, 239, 3, False), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (557).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 56, 733)));
- Table.States (558).Action_List.Set_Capacity (2);
- Add_Action (Table.States (558), 96, Reduce, (220, 1), 0, null,
null);
- Add_Action (Table.States (558), 104, 149);
- Table.States (558).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (558), 220, 734);
- Table.States (558).Kernel := To_Vector ((0 => (133, 24, 1,
False)));
- Table.States (558).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 220, 0)));
- Table.States (559).Action_List.Set_Capacity (3);
- Add_Action (Table.States (559), 24, Reduce, (189, 1), 0, null,
null);
- Add_Action (Table.States (559), 48, 16);
- Add_Action (Table.States (559), 72, 735);
+ Table.States (557).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (557), 79, 31);
+ Add_Action (Table.States (557), 105, 120);
+ Add_Action (Table.States (557), 106, 34);
+ Add_Action (Table.States (557), 107, 35);
+ Table.States (557).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (557), 129, 42);
+ Add_Goto (Table.States (557), 240, 732);
+ Add_Goto (Table.States (557), 273, 93);
+ Add_Goto (Table.States (557), 294, 98);
+ Table.States (557).Kernel := To_Vector ((0 => (246, 56, 2,
False)));
+ Table.States (557).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (558).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (558), (7, 21, 35, 56, 74, 77, 79, 83,
97, 105, 106, 107), (242, 0), 2, null,
+ null);
+ Table.States (558).Kernel := To_Vector ((0 => (242, 41, 0,
False)));
+ Table.States (558).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 242, 2)));
+ Table.States (559).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (559), 79, 31);
+ Add_Action (Table.States (559), 105, 120);
+ Add_Action (Table.States (559), 106, 34);
+ Add_Action (Table.States (559), 107, 35);
Table.States (559).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (559), 187, 736);
- Add_Goto (Table.States (559), 188, 737);
- Add_Goto (Table.States (559), 189, 738);
- Add_Goto (Table.States (559), 257, 739);
- Table.States (559).Kernel := To_Vector ((0 => (218, 26, 0,
False)));
- Table.States (559).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 189, 0)));
- Table.States (560).Action_List.Set_Capacity (18);
- Add_Action (Table.States (560), (13, 24, 25, 28, 29, 30, 40, 46,
47, 48, 49, 50, 51, 63, 66, 69, 71, 104),
- (158, 0), 2, null, null);
- Table.States (560).Kernel := To_Vector ((0 => (158, 157, 0,
True)));
- Table.States (560).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 158, 2)));
+ Add_Goto (Table.States (559), 129, 42);
+ Add_Goto (Table.States (559), 240, 733);
+ Add_Goto (Table.States (559), 273, 93);
+ Add_Goto (Table.States (559), 294, 98);
+ Table.States (559).Kernel := To_Vector ((0 => (246, 56, 2,
False)));
+ Table.States (559).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (560).Action_List.Set_Capacity (9);
+ Add_Action (Table.States (560), 9, 734);
+ Add_Action (Table.States (560), 16, 735);
+ Add_Action (Table.States (560), 29, Reduce, (271, 1), 0, null,
null);
+ Add_Action (Table.States (560), 50, Reduce, (271, 1), 0, null,
null);
+ Add_Action (Table.States (560), 51, 736);
+ Add_Action (Table.States (560), 79, Reduce, (209, 2), 0, null,
null);
+ Add_Action (Table.States (560), 105, Reduce, (209, 2), 0, null,
null);
+ Add_Action (Table.States (560), 106, Reduce, (209, 2), 0, null,
null);
+ Add_Action (Table.States (560), 107, Reduce, (209, 2), 0, null,
null);
+ Table.States (560).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (560), 209, 737);
+ Add_Goto (Table.States (560), 271, 738);
+ Table.States (560).Kernel := To_Vector (((115, 7, 1, False), (115,
7, 2, True), (115, 7, 1, False)));
+ Table.States (560).Minimal_Complete_Actions := To_Vector
(((Reduce, 271, 0), (Reduce, 209, 0)));
Table.States (560).Minimal_Complete_Actions_Recursive := True;
- Table.States (561).Action_List.Set_Capacity (18);
- Add_Action (Table.States (561), (13, 24, 25, 28, 29, 30, 40, 46,
47, 48, 49, 50, 51, 63, 66, 69, 71, 104),
- (158, 1), 2, null, null);
- Table.States (561).Kernel := To_Vector ((0 => (158, 257, 0,
True)));
- Table.States (561).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 158, 2)));
- Table.States (561).Minimal_Complete_Actions_Recursive := True;
- Table.States (562).Action_List.Set_Capacity (24);
- Add_Action (Table.States (562), 4, 1);
- Add_Action (Table.States (562), 5, 2);
- Add_Action (Table.States (562), 13, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (562), 15, 3);
- Add_Action (Table.States (562), 17, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (562), 18, 4);
- Add_Action (Table.States (562), 24, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (562), 26, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (562), 27, 5);
- Add_Action (Table.States (562), 28, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (562), 31, 9);
- Add_Action (Table.States (562), 32, 10);
- Add_Action (Table.States (562), 37, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (562), 41, 13);
- Add_Action (Table.States (562), 48, 16);
- Add_Action (Table.States (562), 52, 20);
- Add_Action (Table.States (562), 57, 21);
- Add_Action (Table.States (562), 58, 22);
- Add_Action (Table.States (562), 61, 24);
- Add_Action (Table.States (562), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (562), 93, 31);
- Add_Action (Table.States (562), 104, 360);
- Add_Action (Table.States (562), 105, 33);
- Add_Action (Table.States (562), 106, 34);
- Table.States (562).Goto_List.Set_Capacity (32);
- Add_Goto (Table.States (562), 113, 36);
- Add_Goto (Table.States (562), 123, 38);
- Add_Goto (Table.States (562), 126, 39);
- Add_Goto (Table.States (562), 128, 41);
- Add_Goto (Table.States (562), 131, 42);
- Add_Goto (Table.States (562), 132, 43);
- Add_Goto (Table.States (562), 133, 44);
- Add_Goto (Table.States (562), 139, 47);
- Add_Goto (Table.States (562), 151, 50);
- Add_Goto (Table.States (562), 152, 51);
- Add_Goto (Table.States (562), 161, 53);
- Add_Goto (Table.States (562), 190, 57);
- Add_Goto (Table.States (562), 196, 59);
- Add_Goto (Table.States (562), 217, 68);
- Add_Goto (Table.States (562), 218, 740);
- Add_Goto (Table.States (562), 222, 70);
- Add_Goto (Table.States (562), 232, 72);
- Add_Goto (Table.States (562), 239, 73);
- Add_Goto (Table.States (562), 257, 83);
- Add_Goto (Table.States (562), 261, 86);
- Add_Goto (Table.States (562), 272, 92);
- Add_Goto (Table.States (562), 276, 93);
- Add_Goto (Table.States (562), 290, 96);
- Add_Goto (Table.States (562), 293, 97);
- Add_Goto (Table.States (562), 294, 98);
- Add_Goto (Table.States (562), 298, 99);
- Add_Goto (Table.States (562), 299, 361);
- Add_Goto (Table.States (562), 300, 390);
- Add_Goto (Table.States (562), 302, 100);
- Add_Goto (Table.States (562), 303, 101);
- Add_Goto (Table.States (562), 306, 363);
- Add_Goto (Table.States (562), 323, 114);
- Table.States (562).Kernel := To_Vector ((0 => (133, 13, 2,
False)));
- Table.States (562).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 218, 0)));
- Table.States (563).Action_List.Set_Capacity (1);
- Add_Action (Table.States (563), 37, 741);
- Table.States (563).Kernel := To_Vector ((0 => (232, 24, 2,
False)));
- Table.States (563).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 37, 741)));
- Table.States (564).Action_List.Set_Capacity (1);
- Add_Action (Table.States (564), 24, 742);
- Table.States (564).Kernel := To_Vector ((0 => (232, 300, 3,
False)));
- Table.States (564).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 742)));
- Table.States (565).Action_List.Set_Capacity (40);
- Add_Action (Table.States (565), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (216, 0), 4,
- generic_subprogram_declaration_0'Access, null);
- Table.States (565).Kernel := To_Vector ((0 => (216, 96, 0,
False)));
- Table.States (565).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 216, 4)));
- Table.States (566).Action_List.Set_Capacity (13);
- Add_Action (Table.States (566), 3, 121);
- Add_Action (Table.States (566), 39, 122);
- Add_Action (Table.States (566), 40, 123);
- Add_Action (Table.States (566), 41, 124);
- Add_Action (Table.States (566), 52, 125);
- Add_Action (Table.States (566), 76, 126);
- Add_Action (Table.States (566), 94, 127);
- Add_Action (Table.States (566), 95, 128);
- Add_Action (Table.States (566), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (566), 103, 129);
- Add_Action (Table.States (566), 104, 119);
- Add_Action (Table.States (566), 105, 33);
+ Table.States (561).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (561), 56, 739);
+ Add_Action (Table.States (561), 76, 236);
+ Add_Action (Table.States (561), 85, 238);
+ Add_Action (Table.States (561), 102, 240);
+ Add_Action (Table.States (561), 103, 241);
+ Table.States (561).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (561), 116, 242);
+ Add_Goto (Table.States (561), 323, 243);
+ Table.States (561).Kernel := To_Vector (((129, 240, 2, True),
(240, 240, 5, True), (240, 240, 2, True),
+ (246, 240, 3, False), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (561).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 56, 739)));
+ Table.States (562).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (562), 97, Reduce, (221, 1), 0, null,
null);
+ Add_Action (Table.States (562), 105, 150);
+ Table.States (562).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (562), 221, 740);
+ Table.States (562).Kernel := To_Vector ((0 => (134, 24, 1,
False)));
+ Table.States (562).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 221, 0)));
+ Table.States (563).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (563), 24, Reduce, (190, 1), 0, null,
null);
+ Add_Action (Table.States (563), 48, 16);
+ Add_Action (Table.States (563), 72, 741);
+ Table.States (563).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (563), 188, 742);
+ Add_Goto (Table.States (563), 189, 743);
+ Add_Goto (Table.States (563), 190, 744);
+ Add_Goto (Table.States (563), 258, 745);
+ Table.States (563).Kernel := To_Vector ((0 => (219, 26, 0,
False)));
+ Table.States (563).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 190, 0)));
+ Table.States (564).Action_List.Set_Capacity (18);
+ Add_Action (Table.States (564), (13, 24, 25, 28, 29, 30, 40, 46,
47, 48, 49, 50, 51, 63, 66, 69, 71, 105),
+ (159, 0), 2, null, null);
+ Table.States (564).Kernel := To_Vector ((0 => (159, 158, 0,
True)));
+ Table.States (564).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 159, 2)));
+ Table.States (564).Minimal_Complete_Actions_Recursive := True;
+ Table.States (565).Action_List.Set_Capacity (18);
+ Add_Action (Table.States (565), (13, 24, 25, 28, 29, 30, 40, 46,
47, 48, 49, 50, 51, 63, 66, 69, 71, 105),
+ (159, 1), 2, null, null);
+ Table.States (565).Kernel := To_Vector ((0 => (159, 258, 0,
True)));
+ Table.States (565).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 159, 2)));
+ Table.States (565).Minimal_Complete_Actions_Recursive := True;
+ Table.States (566).Action_List.Set_Capacity (25);
+ Add_Action (Table.States (566), 4, 1);
+ Add_Action (Table.States (566), 5, 2);
+ Add_Action (Table.States (566), 13, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (566), 15, 3);
+ Add_Action (Table.States (566), 17, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (566), 18, 4);
+ Add_Action (Table.States (566), 24, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (566), 26, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (566), 27, 5);
+ Add_Action (Table.States (566), 28, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (566), 31, 9);
+ Add_Action (Table.States (566), 32, 10);
+ Add_Action (Table.States (566), 37, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (566), 41, 13);
+ Add_Action (Table.States (566), 48, 16);
+ Add_Action (Table.States (566), 52, 20);
+ Add_Action (Table.States (566), 57, 21);
+ Add_Action (Table.States (566), 58, 22);
+ Add_Action (Table.States (566), 61, 24);
+ Add_Action (Table.States (566), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (566), 79, 31);
+ Add_Action (Table.States (566), 94, 32);
+ Add_Action (Table.States (566), 105, 361);
Add_Action (Table.States (566), 106, 34);
- Table.States (566).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (566), 117, 130);
- Add_Goto (Table.States (566), 128, 41);
- Add_Goto (Table.States (566), 191, 131);
- Add_Goto (Table.States (566), 192, 743);
- Add_Goto (Table.States (566), 197, 133);
- Add_Goto (Table.States (566), 239, 134);
- Add_Goto (Table.States (566), 258, 135);
- Add_Goto (Table.States (566), 272, 92);
- Add_Goto (Table.States (566), 275, 136);
- Add_Goto (Table.States (566), 282, 137);
- Add_Goto (Table.States (566), 283, 138);
- Add_Goto (Table.States (566), 284, 139);
- Add_Goto (Table.States (566), 285, 140);
- Add_Goto (Table.States (566), 286, 141);
- Add_Goto (Table.States (566), 287, 142);
- Add_Goto (Table.States (566), 293, 97);
- Add_Goto (Table.States (566), 301, 143);
- Add_Goto (Table.States (566), 320, 144);
- Add_Goto (Table.States (566), 321, 145);
- Add_Goto (Table.States (566), 330, 146);
- Table.States (566).Kernel := To_Vector ((0 => (157, 82, 1,
False)));
- Table.States (566).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (567).Action_List.Set_Capacity (40);
- Add_Action (Table.States (567), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (186, 0), 4,
+ Add_Action (Table.States (566), 107, 35);
+ Table.States (566).Goto_List.Set_Capacity (32);
+ Add_Goto (Table.States (566), 114, 37);
+ Add_Goto (Table.States (566), 124, 39);
+ Add_Goto (Table.States (566), 127, 40);
+ Add_Goto (Table.States (566), 129, 42);
+ Add_Goto (Table.States (566), 132, 43);
+ Add_Goto (Table.States (566), 133, 44);
+ Add_Goto (Table.States (566), 134, 45);
+ Add_Goto (Table.States (566), 140, 48);
+ Add_Goto (Table.States (566), 152, 51);
+ Add_Goto (Table.States (566), 153, 52);
+ Add_Goto (Table.States (566), 162, 54);
+ Add_Goto (Table.States (566), 191, 58);
+ Add_Goto (Table.States (566), 197, 60);
+ Add_Goto (Table.States (566), 218, 69);
+ Add_Goto (Table.States (566), 219, 746);
+ Add_Goto (Table.States (566), 223, 71);
+ Add_Goto (Table.States (566), 233, 73);
+ Add_Goto (Table.States (566), 240, 74);
+ Add_Goto (Table.States (566), 258, 84);
+ Add_Goto (Table.States (566), 262, 87);
+ Add_Goto (Table.States (566), 273, 93);
+ Add_Goto (Table.States (566), 277, 94);
+ Add_Goto (Table.States (566), 291, 97);
+ Add_Goto (Table.States (566), 294, 98);
+ Add_Goto (Table.States (566), 295, 99);
+ Add_Goto (Table.States (566), 299, 100);
+ Add_Goto (Table.States (566), 300, 362);
+ Add_Goto (Table.States (566), 301, 391);
+ Add_Goto (Table.States (566), 303, 101);
+ Add_Goto (Table.States (566), 304, 102);
+ Add_Goto (Table.States (566), 307, 364);
+ Add_Goto (Table.States (566), 324, 115);
+ Table.States (566).Kernel := To_Vector ((0 => (134, 13, 2,
False)));
+ Table.States (566).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 219, 0)));
+ Table.States (567).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (567), 37, 747);
+ Table.States (567).Kernel := To_Vector ((0 => (233, 24, 2,
False)));
+ Table.States (567).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 37, 747)));
+ Table.States (568).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (568), 24, 748);
+ Table.States (568).Kernel := To_Vector ((0 => (233, 301, 3,
False)));
+ Table.States (568).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 748)));
+ Table.States (569).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (569), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (217, 0), 4,
+ generic_subprogram_declaration_0'Access, null);
+ Table.States (569).Kernel := To_Vector ((0 => (217, 97, 0,
False)));
+ Table.States (569).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 217, 4)));
+ Table.States (570).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (570), 3, 122);
+ Add_Action (Table.States (570), 39, 123);
+ Add_Action (Table.States (570), 40, 124);
+ Add_Action (Table.States (570), 41, 125);
+ Add_Action (Table.States (570), 52, 126);
+ Add_Action (Table.States (570), 76, 127);
+ Add_Action (Table.States (570), 79, 31);
+ Add_Action (Table.States (570), 95, 128);
+ Add_Action (Table.States (570), 96, 129);
+ Add_Action (Table.States (570), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (570), 104, 130);
+ Add_Action (Table.States (570), 105, 120);
+ Add_Action (Table.States (570), 106, 34);
+ Add_Action (Table.States (570), 107, 35);
+ Table.States (570).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (570), 118, 131);
+ Add_Goto (Table.States (570), 129, 42);
+ Add_Goto (Table.States (570), 192, 132);
+ Add_Goto (Table.States (570), 193, 749);
+ Add_Goto (Table.States (570), 198, 134);
+ Add_Goto (Table.States (570), 240, 135);
+ Add_Goto (Table.States (570), 259, 136);
+ Add_Goto (Table.States (570), 273, 93);
+ Add_Goto (Table.States (570), 276, 137);
+ Add_Goto (Table.States (570), 283, 138);
+ Add_Goto (Table.States (570), 284, 139);
+ Add_Goto (Table.States (570), 285, 140);
+ Add_Goto (Table.States (570), 286, 141);
+ Add_Goto (Table.States (570), 287, 142);
+ Add_Goto (Table.States (570), 288, 143);
+ Add_Goto (Table.States (570), 294, 98);
+ Add_Goto (Table.States (570), 302, 144);
+ Add_Goto (Table.States (570), 321, 145);
+ Add_Goto (Table.States (570), 322, 146);
+ Add_Goto (Table.States (570), 331, 147);
+ Table.States (570).Kernel := To_Vector ((0 => (158, 83, 1,
False)));
+ Table.States (570).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (571).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (571), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (187, 0), 4,
exception_declaration_0'Access, null);
- Table.States (567).Kernel := To_Vector ((0 => (186, 96, 0,
False)));
- Table.States (567).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 186, 4)));
- Table.States (568).Action_List.Set_Capacity (10);
- Add_Action (Table.States (568), (7, 11, 21, 40, 74, 82, 96, 104,
105, 106), (154, 0), 1, null, null);
- Table.States (568).Kernel := To_Vector ((0 => (154, 16, 0,
False)));
- Table.States (568).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 154, 1)));
- Table.States (569).Action_List.Set_Capacity (6);
- Add_Action (Table.States (569), 7, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (569), 11, 701);
- Add_Action (Table.States (569), 40, 744);
- Add_Action (Table.States (569), 104, 119);
- Add_Action (Table.States (569), 105, 33);
- Add_Action (Table.States (569), 106, 34);
- Table.States (569).Goto_List.Set_Capacity (8);
- Add_Goto (Table.States (569), 114, 745);
- Add_Goto (Table.States (569), 120, 746);
- Add_Goto (Table.States (569), 128, 41);
- Add_Goto (Table.States (569), 239, 484);
- Add_Goto (Table.States (569), 241, 723);
- Add_Goto (Table.States (569), 272, 92);
- Add_Goto (Table.States (569), 293, 97);
- Add_Goto (Table.States (569), 314, 747);
- Table.States (569).Kernel := To_Vector (((244, 154, 3, False),
(244, 154, 4, False), (244, 154, 10, False),
- (244, 154, 2, False), (244, 154, 3, False), (244, 154, 9, False)));
- Table.States (569).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (570).Action_List.Set_Capacity (63);
- Add_Action (Table.States (570), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
- 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
- 88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104,
105, 106), (115, 0), 3,
+ Table.States (571).Kernel := To_Vector ((0 => (187, 97, 0,
False)));
+ Table.States (571).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 187, 4)));
+ Table.States (572).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (572), (7, 11, 21, 40, 74, 79, 83, 97,
105, 106, 107), (155, 0), 1, null, null);
+ Table.States (572).Kernel := To_Vector ((0 => (155, 16, 0,
False)));
+ Table.States (572).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 155, 1)));
+ Table.States (573).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (573), 7, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (573), 11, 707);
+ Add_Action (Table.States (573), 40, 750);
+ Add_Action (Table.States (573), 79, 31);
+ Add_Action (Table.States (573), 105, 120);
+ Add_Action (Table.States (573), 106, 34);
+ Add_Action (Table.States (573), 107, 35);
+ Table.States (573).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (573), 115, 751);
+ Add_Goto (Table.States (573), 121, 752);
+ Add_Goto (Table.States (573), 129, 42);
+ Add_Goto (Table.States (573), 240, 487);
+ Add_Goto (Table.States (573), 242, 729);
+ Add_Goto (Table.States (573), 273, 93);
+ Add_Goto (Table.States (573), 294, 98);
+ Add_Goto (Table.States (573), 315, 753);
+ Table.States (573).Kernel := To_Vector (((245, 155, 3, False),
(245, 155, 4, False), (245, 155, 10, False),
+ (245, 155, 2, False), (245, 155, 3, False), (245, 155, 9, False)));
+ Table.States (573).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (574).Action_List.Set_Capacity (64);
+ Add_Action (Table.States (574), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+ 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
105, 106, 107), (116, 0), 3,
actual_parameter_part_0'Access, null);
- Table.States (570).Kernel := To_Vector ((0 => (115, 77, 0,
False)));
- Table.States (570).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 115, 3)));
- Table.States (571).Action_List.Set_Capacity (63);
- Add_Action (Table.States (571), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
- 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
- 88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104,
105, 106), (115, 1), 3,
+ Table.States (574).Kernel := To_Vector ((0 => (116, 77, 0,
False)));
+ Table.States (574).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 116, 3)));
+ Table.States (575).Action_List.Set_Capacity (64);
+ Add_Action (Table.States (575), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+ 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
105, 106, 107), (116, 1), 3,
actual_parameter_part_1'Access, null);
- Table.States (571).Kernel := To_Vector ((0 => (115, 77, 0,
False)));
- Table.States (571).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 115, 3)));
- Table.States (572).Action_List.Set_Capacity (63);
- Add_Action (Table.States (572), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
- 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
- 88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104,
105, 106), (239, 0), 4, name_0'Access,
+ Table.States (575).Kernel := To_Vector ((0 => (116, 77, 0,
False)));
+ Table.States (575).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 116, 3)));
+ Table.States (576).Action_List.Set_Capacity (64);
+ Add_Action (Table.States (576), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+ 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
105, 106, 107), (240, 0), 4, name_0'Access,
null);
- Table.States (572).Kernel := To_Vector ((0 => (239, 77, 0, True)));
- Table.States (572).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 239, 4)));
- Table.States (572).Minimal_Complete_Actions_Recursive := True;
- Table.States (573).Action_List.Set_Capacity (11);
- Add_Action (Table.States (573), 3, 121);
- Add_Action (Table.States (573), 39, 122);
- Add_Action (Table.States (573), 40, 123);
- Add_Action (Table.States (573), 41, 124);
- Add_Action (Table.States (573), 76, 126);
- Add_Action (Table.States (573), 94, 127);
- Add_Action (Table.States (573), 95, 128);
- Add_Action (Table.States (573), 103, 129);
- Add_Action (Table.States (573), 104, 119);
- Add_Action (Table.States (573), 105, 33);
- Add_Action (Table.States (573), 106, 34);
- Table.States (573).Goto_List.Set_Capacity (12);
- Add_Goto (Table.States (573), 117, 130);
- Add_Goto (Table.States (573), 128, 41);
- Add_Goto (Table.States (573), 197, 133);
- Add_Goto (Table.States (573), 239, 274);
- Add_Goto (Table.States (573), 258, 135);
- Add_Goto (Table.States (573), 272, 92);
- Add_Goto (Table.States (573), 277, 748);
- Add_Goto (Table.States (573), 293, 97);
- Add_Goto (Table.States (573), 301, 479);
- Add_Goto (Table.States (573), 320, 144);
- Add_Goto (Table.States (573), 321, 145);
- Add_Goto (Table.States (573), 330, 146);
- Table.States (573).Kernel := To_Vector ((0 => (278, 83, 3, True)));
- Table.States (573).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (573).Minimal_Complete_Actions_Recursive := True;
- Table.States (574).Action_List.Set_Capacity (46);
- Add_Action (Table.States (574), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (123, 0), 4, assignment_statement_0'Access, null);
- Table.States (574).Kernel := To_Vector ((0 => (123, 96, 0,
False)));
- Table.States (574).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 4)));
- Table.States (575).Action_List.Set_Capacity (12);
- Add_Action (Table.States (575), 3, 121);
- Add_Action (Table.States (575), 39, 122);
- Add_Action (Table.States (575), 40, 123);
- Add_Action (Table.States (575), 41, 124);
- Add_Action (Table.States (575), 52, 125);
- Add_Action (Table.States (575), 76, 126);
- Add_Action (Table.States (575), 94, 127);
- Add_Action (Table.States (575), 95, 128);
- Add_Action (Table.States (575), 103, 129);
- Add_Action (Table.States (575), 104, 119);
- Add_Action (Table.States (575), 105, 33);
- Add_Action (Table.States (575), 106, 34);
- Table.States (575).Goto_List.Set_Capacity (19);
- Add_Goto (Table.States (575), 117, 130);
- Add_Goto (Table.States (575), 128, 41);
- Add_Goto (Table.States (575), 191, 749);
- Add_Goto (Table.States (575), 197, 133);
- Add_Goto (Table.States (575), 239, 134);
- Add_Goto (Table.States (575), 258, 135);
- Add_Goto (Table.States (575), 272, 92);
- Add_Goto (Table.States (575), 275, 136);
- Add_Goto (Table.States (575), 282, 137);
- Add_Goto (Table.States (575), 283, 138);
- Add_Goto (Table.States (575), 284, 139);
- Add_Goto (Table.States (575), 285, 140);
- Add_Goto (Table.States (575), 286, 141);
- Add_Goto (Table.States (575), 287, 142);
- Add_Goto (Table.States (575), 293, 97);
- Add_Goto (Table.States (575), 301, 143);
- Add_Goto (Table.States (575), 320, 144);
- Add_Goto (Table.States (575), 321, 145);
- Add_Goto (Table.States (575), 330, 146);
- Table.States (575).Kernel := To_Vector ((0 => (129, 76, 2,
False)));
- Table.States (575).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
- Table.States (576).Action_List.Set_Capacity (13);
- Add_Action (Table.States (576), 3, 121);
- Add_Action (Table.States (576), 39, 122);
- Add_Action (Table.States (576), 40, 474);
- Add_Action (Table.States (576), 41, 124);
- Add_Action (Table.States (576), 76, 126);
- Add_Action (Table.States (576), 77, Reduce, (254, 4), 0, null,
null);
- Add_Action (Table.States (576), 94, 127);
- Add_Action (Table.States (576), 95, 128);
- Add_Action (Table.States (576), 96, Reduce, (254, 4), 0, null,
null);
- Add_Action (Table.States (576), 103, 129);
- Add_Action (Table.States (576), 104, 492);
- Add_Action (Table.States (576), 105, 33);
- Add_Action (Table.States (576), 106, 34);
- Table.States (576).Goto_List.Set_Capacity (17);
- Add_Goto (Table.States (576), 117, 130);
- Add_Goto (Table.States (576), 128, 41);
- Add_Goto (Table.States (576), 167, 750);
- Add_Goto (Table.States (576), 197, 133);
- Add_Goto (Table.States (576), 219, 493);
- Add_Goto (Table.States (576), 239, 477);
- Add_Goto (Table.States (576), 254, 494);
- Add_Goto (Table.States (576), 255, 495);
- Add_Goto (Table.States (576), 258, 135);
- Add_Goto (Table.States (576), 272, 92);
- Add_Goto (Table.States (576), 277, 478);
- Add_Goto (Table.States (576), 293, 97);
- Add_Goto (Table.States (576), 301, 479);
- Add_Goto (Table.States (576), 314, 480);
- Add_Goto (Table.States (576), 320, 144);
- Add_Goto (Table.States (576), 321, 145);
- Add_Goto (Table.States (576), 330, 146);
- Table.States (576).Kernel := To_Vector (((179, 76, 3, False),
(199, 76, 1, False)));
- Table.States (576).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 255, 0)));
- Table.States (577).Action_List.Set_Capacity (2);
- Add_Action (Table.States (577), 74, 337);
- Add_Action (Table.States (577), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (577).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (577), 122, 751);
- Table.States (577).Kernel := To_Vector ((0 => (179, 253, 1,
False)));
- Table.States (577).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (578).Action_List.Set_Capacity (1);
- Add_Action (Table.States (578), 39, 752);
- Table.States (578).Kernel := To_Vector ((0 => (213, 35, 3,
False)));
- Table.States (578).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 39, 752)));
- Table.States (579).Action_List.Set_Capacity (1);
- Add_Action (Table.States (579), 39, 753);
- Table.States (579).Kernel := To_Vector ((0 => (213, 35, 3,
False)));
- Table.States (579).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 39, 753)));
- Table.States (580).Action_List.Set_Capacity (21);
- Add_Action (Table.States (580), 3, 121);
- Add_Action (Table.States (580), 15, 258);
- Add_Action (Table.States (580), 28, 259);
- Add_Action (Table.States (580), 32, 260);
- Add_Action (Table.States (580), 39, 122);
- Add_Action (Table.States (580), 40, 261);
- Add_Action (Table.States (580), 41, 262);
- Add_Action (Table.States (580), 44, 263);
- Add_Action (Table.States (580), 52, 125);
- Add_Action (Table.States (580), 74, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (580), 76, 126);
- Add_Action (Table.States (580), 77, Reduce, (124, 5), 0, null,
null);
- Add_Conflict (Table.States (580), 77, (192, 1), 0, null, null);
- Add_Action (Table.States (580), 79, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (580), 83, Reduce, (124, 5), 0, null,
null);
- Add_Action (Table.States (580), 87, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (580), 94, 127);
+ Table.States (576).Kernel := To_Vector ((0 => (240, 77, 0, True)));
+ Table.States (576).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 240, 4)));
+ Table.States (576).Minimal_Complete_Actions_Recursive := True;
+ Table.States (577).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (577), 3, 122);
+ Add_Action (Table.States (577), 39, 123);
+ Add_Action (Table.States (577), 40, 124);
+ Add_Action (Table.States (577), 41, 125);
+ Add_Action (Table.States (577), 76, 127);
+ Add_Action (Table.States (577), 79, 31);
+ Add_Action (Table.States (577), 95, 128);
+ Add_Action (Table.States (577), 96, 129);
+ Add_Action (Table.States (577), 104, 130);
+ Add_Action (Table.States (577), 105, 120);
+ Add_Action (Table.States (577), 106, 34);
+ Add_Action (Table.States (577), 107, 35);
+ Table.States (577).Goto_List.Set_Capacity (12);
+ Add_Goto (Table.States (577), 118, 131);
+ Add_Goto (Table.States (577), 129, 42);
+ Add_Goto (Table.States (577), 198, 134);
+ Add_Goto (Table.States (577), 240, 275);
+ Add_Goto (Table.States (577), 259, 136);
+ Add_Goto (Table.States (577), 273, 93);
+ Add_Goto (Table.States (577), 278, 754);
+ Add_Goto (Table.States (577), 294, 98);
+ Add_Goto (Table.States (577), 302, 482);
+ Add_Goto (Table.States (577), 321, 145);
+ Add_Goto (Table.States (577), 322, 146);
+ Add_Goto (Table.States (577), 331, 147);
+ Table.States (577).Kernel := To_Vector ((0 => (279, 84, 3, True)));
+ Table.States (577).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (577).Minimal_Complete_Actions_Recursive := True;
+ Table.States (578).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (578), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (124, 0), 4, assignment_statement_0'Access, null);
+ Table.States (578).Kernel := To_Vector ((0 => (124, 97, 0,
False)));
+ Table.States (578).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 124, 4)));
+ Table.States (579).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (579), 3, 122);
+ Add_Action (Table.States (579), 39, 123);
+ Add_Action (Table.States (579), 40, 124);
+ Add_Action (Table.States (579), 41, 125);
+ Add_Action (Table.States (579), 52, 126);
+ Add_Action (Table.States (579), 76, 127);
+ Add_Action (Table.States (579), 79, 31);
+ Add_Action (Table.States (579), 95, 128);
+ Add_Action (Table.States (579), 96, 129);
+ Add_Action (Table.States (579), 104, 130);
+ Add_Action (Table.States (579), 105, 120);
+ Add_Action (Table.States (579), 106, 34);
+ Add_Action (Table.States (579), 107, 35);
+ Table.States (579).Goto_List.Set_Capacity (19);
+ Add_Goto (Table.States (579), 118, 131);
+ Add_Goto (Table.States (579), 129, 42);
+ Add_Goto (Table.States (579), 192, 755);
+ Add_Goto (Table.States (579), 198, 134);
+ Add_Goto (Table.States (579), 240, 135);
+ Add_Goto (Table.States (579), 259, 136);
+ Add_Goto (Table.States (579), 273, 93);
+ Add_Goto (Table.States (579), 276, 137);
+ Add_Goto (Table.States (579), 283, 138);
+ Add_Goto (Table.States (579), 284, 139);
+ Add_Goto (Table.States (579), 285, 140);
+ Add_Goto (Table.States (579), 286, 141);
+ Add_Goto (Table.States (579), 287, 142);
+ Add_Goto (Table.States (579), 288, 143);
+ Add_Goto (Table.States (579), 294, 98);
+ Add_Goto (Table.States (579), 302, 144);
+ Add_Goto (Table.States (579), 321, 145);
+ Add_Goto (Table.States (579), 322, 146);
+ Add_Goto (Table.States (579), 331, 147);
+ Table.States (579).Kernel := To_Vector ((0 => (130, 76, 2,
False)));
+ Table.States (579).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
+ Table.States (580).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (580), 3, 122);
+ Add_Action (Table.States (580), 39, 123);
+ Add_Action (Table.States (580), 40, 477);
+ Add_Action (Table.States (580), 41, 125);
+ Add_Action (Table.States (580), 76, 127);
+ Add_Action (Table.States (580), 77, Reduce, (255, 4), 0, null,
null);
+ Add_Action (Table.States (580), 79, 31);
Add_Action (Table.States (580), 95, 128);
- Add_Action (Table.States (580), 103, 129);
- Add_Action (Table.States (580), 104, 119);
- Add_Action (Table.States (580), 105, 33);
- Add_Action (Table.States (580), 106, 264);
- Table.States (580).Goto_List.Set_Capacity (29);
- Add_Goto (Table.States (580), 117, 130);
- Add_Goto (Table.States (580), 124, 265);
- Add_Goto (Table.States (580), 125, 266);
- Add_Goto (Table.States (580), 128, 41);
- Add_Goto (Table.States (580), 136, 267);
- Add_Goto (Table.States (580), 153, 268);
- Add_Goto (Table.States (580), 165, 269);
- Add_Goto (Table.States (580), 166, 270);
- Add_Goto (Table.States (580), 191, 271);
- Add_Goto (Table.States (580), 192, 754);
- Add_Goto (Table.States (580), 197, 133);
- Add_Goto (Table.States (580), 221, 273);
- Add_Goto (Table.States (580), 239, 274);
- Add_Goto (Table.States (580), 258, 135);
- Add_Goto (Table.States (580), 272, 92);
- Add_Goto (Table.States (580), 273, 275);
- Add_Goto (Table.States (580), 275, 136);
- Add_Goto (Table.States (580), 277, 276);
- Add_Goto (Table.States (580), 282, 137);
- Add_Goto (Table.States (580), 283, 138);
- Add_Goto (Table.States (580), 284, 139);
- Add_Goto (Table.States (580), 285, 140);
- Add_Goto (Table.States (580), 286, 141);
- Add_Goto (Table.States (580), 287, 142);
- Add_Goto (Table.States (580), 293, 97);
- Add_Goto (Table.States (580), 301, 277);
- Add_Goto (Table.States (580), 320, 144);
+ Add_Action (Table.States (580), 96, 129);
+ Add_Action (Table.States (580), 97, Reduce, (255, 4), 0, null,
null);
+ Add_Action (Table.States (580), 104, 130);
+ Add_Action (Table.States (580), 105, 495);
+ Add_Action (Table.States (580), 106, 34);
+ Add_Action (Table.States (580), 107, 35);
+ Table.States (580).Goto_List.Set_Capacity (17);
+ Add_Goto (Table.States (580), 118, 131);
+ Add_Goto (Table.States (580), 129, 42);
+ Add_Goto (Table.States (580), 168, 756);
+ Add_Goto (Table.States (580), 198, 134);
+ Add_Goto (Table.States (580), 220, 496);
+ Add_Goto (Table.States (580), 240, 480);
+ Add_Goto (Table.States (580), 255, 497);
+ Add_Goto (Table.States (580), 256, 498);
+ Add_Goto (Table.States (580), 259, 136);
+ Add_Goto (Table.States (580), 273, 93);
+ Add_Goto (Table.States (580), 278, 481);
+ Add_Goto (Table.States (580), 294, 98);
+ Add_Goto (Table.States (580), 302, 482);
+ Add_Goto (Table.States (580), 315, 483);
Add_Goto (Table.States (580), 321, 145);
- Add_Goto (Table.States (580), 330, 146);
- Table.States (580).Kernel := To_Vector (((117, 76, 4, False),
(117, 76, 2, False), (117, 76, 3, False),
- (117, 76, 3, False), (117, 76, 1, False), (256, 76, 1, False)));
- Table.States (580).Minimal_Complete_Actions := To_Vector
(((Reduce, 125, 0), (Reduce, 192, 0)));
+ Add_Goto (Table.States (580), 322, 146);
+ Add_Goto (Table.States (580), 331, 147);
+ Table.States (580).Kernel := To_Vector (((180, 76, 3, False),
(200, 76, 1, False)));
+ Table.States (580).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 256, 0)));
Table.States (581).Action_List.Set_Capacity (2);
- Add_Action (Table.States (581), (74, 96), (256, 1), 1, null, null);
- Table.States (581).Kernel := To_Vector ((0 => (256, 117, 0,
False)));
- Table.States (581).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 256, 1)));
- Table.States (582).Action_List.Set_Capacity (2);
- Add_Action (Table.States (582), 74, 337);
- Add_Action (Table.States (582), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (582).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (582), 122, 755);
- Table.States (582).Kernel := To_Vector ((0 => (193, 256, 1,
False)));
- Table.States (582).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (583).Action_List.Set_Capacity (2);
- Add_Action (Table.States (583), 74, 337);
- Add_Action (Table.States (583), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (583).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (583), 122, 756);
- Table.States (583).Kernel := To_Vector ((0 => (243, 41, 1,
False)));
- Table.States (583).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (584).Action_List.Set_Capacity (2);
- Add_Action (Table.States (584), 74, 337);
- Add_Action (Table.States (584), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (584).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (584), 122, 757);
- Table.States (584).Kernel := To_Vector ((0 => (112, 6, 1, False)));
- Table.States (584).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
+ Add_Action (Table.States (581), 74, 338);
+ Add_Action (Table.States (581), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (581).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (581), 123, 757);
+ Table.States (581).Kernel := To_Vector ((0 => (180, 254, 1,
False)));
+ Table.States (581).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (582).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (582), 39, 758);
+ Table.States (582).Kernel := To_Vector ((0 => (214, 35, 3,
False)));
+ Table.States (582).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 39, 758)));
+ Table.States (583).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (583), 39, 759);
+ Table.States (583).Kernel := To_Vector ((0 => (214, 35, 3,
False)));
+ Table.States (583).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 39, 759)));
+ Table.States (584).Action_List.Set_Capacity (22);
+ Add_Action (Table.States (584), 3, 122);
+ Add_Action (Table.States (584), 15, 259);
+ Add_Action (Table.States (584), 28, 260);
+ Add_Action (Table.States (584), 32, 261);
+ Add_Action (Table.States (584), 39, 123);
+ Add_Action (Table.States (584), 40, 262);
+ Add_Action (Table.States (584), 41, 263);
+ Add_Action (Table.States (584), 44, 264);
+ Add_Action (Table.States (584), 52, 126);
+ Add_Action (Table.States (584), 74, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (584), 76, 127);
+ Add_Action (Table.States (584), 77, Reduce, (125, 6), 0, null,
null);
+ Add_Conflict (Table.States (584), 77, (193, 1), 0, null, null);
+ Add_Action (Table.States (584), 79, 31);
+ Add_Action (Table.States (584), 80, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (584), 84, Reduce, (125, 6), 0, null,
null);
+ Add_Action (Table.States (584), 88, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (584), 95, 128);
+ Add_Action (Table.States (584), 96, 129);
+ Add_Action (Table.States (584), 104, 130);
+ Add_Action (Table.States (584), 105, 120);
+ Add_Action (Table.States (584), 106, 34);
+ Add_Action (Table.States (584), 107, 265);
+ Table.States (584).Goto_List.Set_Capacity (29);
+ Add_Goto (Table.States (584), 118, 131);
+ Add_Goto (Table.States (584), 125, 266);
+ Add_Goto (Table.States (584), 126, 267);
+ Add_Goto (Table.States (584), 129, 42);
+ Add_Goto (Table.States (584), 137, 268);
+ Add_Goto (Table.States (584), 154, 269);
+ Add_Goto (Table.States (584), 166, 270);
+ Add_Goto (Table.States (584), 167, 271);
+ Add_Goto (Table.States (584), 192, 272);
+ Add_Goto (Table.States (584), 193, 760);
+ Add_Goto (Table.States (584), 198, 134);
+ Add_Goto (Table.States (584), 222, 274);
+ Add_Goto (Table.States (584), 240, 275);
+ Add_Goto (Table.States (584), 259, 136);
+ Add_Goto (Table.States (584), 273, 93);
+ Add_Goto (Table.States (584), 274, 276);
+ Add_Goto (Table.States (584), 276, 137);
+ Add_Goto (Table.States (584), 278, 277);
+ Add_Goto (Table.States (584), 283, 138);
+ Add_Goto (Table.States (584), 284, 139);
+ Add_Goto (Table.States (584), 285, 140);
+ Add_Goto (Table.States (584), 286, 141);
+ Add_Goto (Table.States (584), 287, 142);
+ Add_Goto (Table.States (584), 288, 143);
+ Add_Goto (Table.States (584), 294, 98);
+ Add_Goto (Table.States (584), 302, 278);
+ Add_Goto (Table.States (584), 321, 145);
+ Add_Goto (Table.States (584), 322, 146);
+ Add_Goto (Table.States (584), 331, 147);
+ Table.States (584).Kernel := To_Vector (((118, 76, 4, False),
(118, 76, 2, False), (118, 76, 3, False),
+ (118, 76, 4, False), (118, 76, 3, False), (118, 76, 1, False),
(257, 76, 1, False)));
+ Table.States (584).Minimal_Complete_Actions := To_Vector
(((Reduce, 126, 0), (Reduce, 193, 0)));
Table.States (585).Action_List.Set_Capacity (2);
- Add_Action (Table.States (585), 74, 337);
- Add_Action (Table.States (585), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (585).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (585), 122, 758);
- Table.States (585).Kernel := To_Vector ((0 => (308, 60, 1,
False)));
- Table.States (585).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (586).Action_List.Set_Capacity (6);
- Add_Action (Table.States (586), 74, 337);
- Add_Action (Table.States (586), 76, 235);
- Add_Action (Table.States (586), 84, 237);
- Add_Action (Table.States (586), 96, Reduce, (122, 1), 0, null,
null);
- Add_Action (Table.States (586), 101, 239);
- Add_Action (Table.States (586), 102, 240);
- Table.States (586).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (586), 115, 241);
- Add_Goto (Table.States (586), 122, 759);
- Add_Goto (Table.States (586), 322, 242);
- Table.States (586).Kernel := To_Vector (((128, 239, 2, True),
(239, 239, 5, True), (239, 239, 2, True),
- (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (311, 239, 1, False)));
- Table.States (586).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (587).Action_List.Set_Capacity (16);
- Add_Action (Table.States (587), 13, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (587), 25, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (587), 28, 183);
- Add_Action (Table.States (587), 29, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (587), 30, 8);
- Add_Action (Table.States (587), 40, 12);
- Add_Action (Table.States (587), 46, 14);
- Add_Action (Table.States (587), 47, 15);
- Add_Action (Table.States (587), 48, 16);
- Add_Action (Table.States (587), 50, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (587), 51, 19);
- Add_Action (Table.States (587), 63, 25);
- Add_Action (Table.States (587), 66, 26);
- Add_Action (Table.States (587), 69, 27);
- Add_Action (Table.States (587), 71, 28);
- Add_Action (Table.States (587), 104, 185);
- Table.States (587).Goto_List.Set_Capacity (53);
- Add_Goto (Table.States (587), 112, 35);
- Add_Goto (Table.States (587), 121, 37);
- Add_Goto (Table.States (587), 127, 40);
- Add_Goto (Table.States (587), 134, 45);
- Add_Goto (Table.States (587), 135, 46);
- Add_Goto (Table.States (587), 157, 391);
- Add_Goto (Table.States (587), 158, 392);
- Add_Goto (Table.States (587), 159, 760);
- Add_Goto (Table.States (587), 179, 54);
- Add_Goto (Table.States (587), 182, 55);
- Add_Goto (Table.States (587), 186, 56);
- Add_Goto (Table.States (587), 193, 58);
- Add_Goto (Table.States (587), 206, 60);
- Add_Goto (Table.States (587), 207, 61);
- Add_Goto (Table.States (587), 209, 62);
- Add_Goto (Table.States (587), 210, 63);
- Add_Goto (Table.States (587), 213, 64);
- Add_Goto (Table.States (587), 214, 65);
- Add_Goto (Table.States (587), 215, 66);
- Add_Goto (Table.States (587), 216, 67);
- Add_Goto (Table.States (587), 219, 69);
- Add_Goto (Table.States (587), 223, 71);
- Add_Goto (Table.States (587), 243, 74);
- Add_Goto (Table.States (587), 244, 75);
- Add_Goto (Table.States (587), 245, 76);
- Add_Goto (Table.States (587), 246, 77);
- Add_Goto (Table.States (587), 247, 78);
- Add_Goto (Table.States (587), 248, 79);
- Add_Goto (Table.States (587), 249, 80);
- Add_Goto (Table.States (587), 250, 81);
- Add_Goto (Table.States (587), 251, 82);
- Add_Goto (Table.States (587), 257, 394);
- Add_Goto (Table.States (587), 259, 84);
- Add_Goto (Table.States (587), 260, 85);
- Add_Goto (Table.States (587), 262, 87);
- Add_Goto (Table.States (587), 263, 88);
- Add_Goto (Table.States (587), 264, 89);
- Add_Goto (Table.States (587), 265, 90);
- Add_Goto (Table.States (587), 271, 91);
- Add_Goto (Table.States (587), 281, 94);
- Add_Goto (Table.States (587), 289, 95);
- Add_Goto (Table.States (587), 304, 102);
- Add_Goto (Table.States (587), 305, 103);
- Add_Goto (Table.States (587), 307, 105);
- Add_Goto (Table.States (587), 308, 106);
- Add_Goto (Table.States (587), 309, 107);
- Add_Goto (Table.States (587), 311, 108);
- Add_Goto (Table.States (587), 313, 109);
- Add_Goto (Table.States (587), 316, 111);
- Add_Goto (Table.States (587), 317, 112);
- Add_Goto (Table.States (587), 319, 113);
- Add_Goto (Table.States (587), 325, 115);
- Add_Goto (Table.States (587), 331, 116);
- Table.States (587).Kernel := To_Vector ((0 => (307, 35, 3,
False)));
- Table.States (587).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 159, 0)));
- Table.States (588).Action_List.Set_Capacity (40);
- Add_Action (Table.States (588), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (309, 0), 4,
+ Add_Action (Table.States (585), (74, 97), (257, 1), 1, null, null);
+ Table.States (585).Kernel := To_Vector ((0 => (257, 118, 0,
False)));
+ Table.States (585).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 257, 1)));
+ Table.States (586).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (586), 74, 338);
+ Add_Action (Table.States (586), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (586).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (586), 123, 761);
+ Table.States (586).Kernel := To_Vector ((0 => (194, 257, 1,
False)));
+ Table.States (586).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (587).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (587), 74, 338);
+ Add_Action (Table.States (587), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (587).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (587), 123, 762);
+ Table.States (587).Kernel := To_Vector ((0 => (244, 41, 1,
False)));
+ Table.States (587).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (588).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (588), 74, 338);
+ Add_Action (Table.States (588), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (588).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (588), 123, 763);
+ Table.States (588).Kernel := To_Vector ((0 => (113, 6, 1, False)));
+ Table.States (588).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (589).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (589), 74, 338);
+ Add_Action (Table.States (589), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (589).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (589), 123, 764);
+ Table.States (589).Kernel := To_Vector ((0 => (309, 60, 1,
False)));
+ Table.States (589).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (590).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (590), 74, 338);
+ Add_Action (Table.States (590), 76, 236);
+ Add_Action (Table.States (590), 85, 238);
+ Add_Action (Table.States (590), 97, Reduce, (123, 1), 0, null,
null);
+ Add_Action (Table.States (590), 102, 240);
+ Add_Action (Table.States (590), 103, 241);
+ Table.States (590).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (590), 116, 242);
+ Add_Goto (Table.States (590), 123, 765);
+ Add_Goto (Table.States (590), 323, 243);
+ Table.States (590).Kernel := To_Vector (((129, 240, 2, True),
(240, 240, 5, True), (240, 240, 2, True),
+ (273, 240, 3, True), (294, 240, 2, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (312, 240, 1, False)));
+ Table.States (590).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ end Subr_11;
+ procedure Subr_12
+ is begin
+ Table.States (591).Action_List.Set_Capacity (16);
+ Add_Action (Table.States (591), 13, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (591), 25, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (591), 28, 184);
+ Add_Action (Table.States (591), 29, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (591), 30, 8);
+ Add_Action (Table.States (591), 40, 12);
+ Add_Action (Table.States (591), 46, 14);
+ Add_Action (Table.States (591), 47, 15);
+ Add_Action (Table.States (591), 48, 16);
+ Add_Action (Table.States (591), 50, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (591), 51, 19);
+ Add_Action (Table.States (591), 63, 25);
+ Add_Action (Table.States (591), 66, 26);
+ Add_Action (Table.States (591), 69, 27);
+ Add_Action (Table.States (591), 71, 28);
+ Add_Action (Table.States (591), 105, 186);
+ Table.States (591).Goto_List.Set_Capacity (53);
+ Add_Goto (Table.States (591), 113, 36);
+ Add_Goto (Table.States (591), 122, 38);
+ Add_Goto (Table.States (591), 128, 41);
+ Add_Goto (Table.States (591), 135, 46);
+ Add_Goto (Table.States (591), 136, 47);
+ Add_Goto (Table.States (591), 158, 392);
+ Add_Goto (Table.States (591), 159, 393);
+ Add_Goto (Table.States (591), 160, 766);
+ Add_Goto (Table.States (591), 180, 55);
+ Add_Goto (Table.States (591), 183, 56);
+ Add_Goto (Table.States (591), 187, 57);
+ Add_Goto (Table.States (591), 194, 59);
+ Add_Goto (Table.States (591), 207, 61);
+ Add_Goto (Table.States (591), 208, 62);
+ Add_Goto (Table.States (591), 210, 63);
+ Add_Goto (Table.States (591), 211, 64);
+ Add_Goto (Table.States (591), 214, 65);
+ Add_Goto (Table.States (591), 215, 66);
+ Add_Goto (Table.States (591), 216, 67);
+ Add_Goto (Table.States (591), 217, 68);
+ Add_Goto (Table.States (591), 220, 70);
+ Add_Goto (Table.States (591), 224, 72);
+ Add_Goto (Table.States (591), 244, 75);
+ Add_Goto (Table.States (591), 245, 76);
+ Add_Goto (Table.States (591), 246, 77);
+ Add_Goto (Table.States (591), 247, 78);
+ Add_Goto (Table.States (591), 248, 79);
+ Add_Goto (Table.States (591), 249, 80);
+ Add_Goto (Table.States (591), 250, 81);
+ Add_Goto (Table.States (591), 251, 82);
+ Add_Goto (Table.States (591), 252, 83);
+ Add_Goto (Table.States (591), 258, 395);
+ Add_Goto (Table.States (591), 260, 85);
+ Add_Goto (Table.States (591), 261, 86);
+ Add_Goto (Table.States (591), 263, 88);
+ Add_Goto (Table.States (591), 264, 89);
+ Add_Goto (Table.States (591), 265, 90);
+ Add_Goto (Table.States (591), 266, 91);
+ Add_Goto (Table.States (591), 272, 92);
+ Add_Goto (Table.States (591), 282, 95);
+ Add_Goto (Table.States (591), 290, 96);
+ Add_Goto (Table.States (591), 305, 103);
+ Add_Goto (Table.States (591), 306, 104);
+ Add_Goto (Table.States (591), 308, 106);
+ Add_Goto (Table.States (591), 309, 107);
+ Add_Goto (Table.States (591), 310, 108);
+ Add_Goto (Table.States (591), 312, 109);
+ Add_Goto (Table.States (591), 314, 110);
+ Add_Goto (Table.States (591), 317, 112);
+ Add_Goto (Table.States (591), 318, 113);
+ Add_Goto (Table.States (591), 320, 114);
+ Add_Goto (Table.States (591), 326, 116);
+ Add_Goto (Table.States (591), 332, 117);
+ Table.States (591).Kernel := To_Vector ((0 => (308, 35, 3,
False)));
+ Table.States (591).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 160, 0)));
+ Table.States (592).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (592), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (310, 0), 4,
subprogram_declaration_0'Access, null);
- Table.States (588).Kernel := To_Vector ((0 => (309, 96, 0,
False)));
- Table.States (588).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 309, 4)));
- Table.States (589).Action_List.Set_Capacity (24);
- Add_Action (Table.States (589), 4, 1);
- Add_Action (Table.States (589), 5, 2);
- Add_Action (Table.States (589), 13, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (589), 15, 3);
- Add_Action (Table.States (589), 17, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (589), 18, 4);
- Add_Action (Table.States (589), 24, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (589), 26, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (589), 27, 5);
- Add_Action (Table.States (589), 28, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (589), 31, 9);
- Add_Action (Table.States (589), 32, 10);
- Add_Action (Table.States (589), 37, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (589), 41, 13);
- Add_Action (Table.States (589), 48, 16);
- Add_Action (Table.States (589), 52, 20);
- Add_Action (Table.States (589), 57, 21);
- Add_Action (Table.States (589), 58, 22);
- Add_Action (Table.States (589), 61, 24);
- Add_Action (Table.States (589), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (589), 93, 31);
- Add_Action (Table.States (589), 104, 360);
- Add_Action (Table.States (589), 105, 33);
- Add_Action (Table.States (589), 106, 34);
- Table.States (589).Goto_List.Set_Capacity (32);
- Add_Goto (Table.States (589), 113, 36);
- Add_Goto (Table.States (589), 123, 38);
- Add_Goto (Table.States (589), 126, 39);
- Add_Goto (Table.States (589), 128, 41);
- Add_Goto (Table.States (589), 131, 42);
- Add_Goto (Table.States (589), 132, 43);
- Add_Goto (Table.States (589), 133, 44);
- Add_Goto (Table.States (589), 139, 47);
- Add_Goto (Table.States (589), 151, 50);
- Add_Goto (Table.States (589), 152, 51);
- Add_Goto (Table.States (589), 161, 53);
- Add_Goto (Table.States (589), 190, 57);
- Add_Goto (Table.States (589), 196, 59);
- Add_Goto (Table.States (589), 217, 68);
- Add_Goto (Table.States (589), 218, 761);
- Add_Goto (Table.States (589), 222, 70);
- Add_Goto (Table.States (589), 232, 72);
- Add_Goto (Table.States (589), 239, 73);
- Add_Goto (Table.States (589), 257, 83);
- Add_Goto (Table.States (589), 261, 86);
- Add_Goto (Table.States (589), 272, 92);
- Add_Goto (Table.States (589), 276, 93);
- Add_Goto (Table.States (589), 290, 96);
- Add_Goto (Table.States (589), 293, 97);
- Add_Goto (Table.States (589), 294, 98);
- Add_Goto (Table.States (589), 298, 99);
- Add_Goto (Table.States (589), 299, 361);
- Add_Goto (Table.States (589), 300, 390);
- Add_Goto (Table.States (589), 302, 100);
- Add_Goto (Table.States (589), 303, 101);
- Add_Goto (Table.States (589), 306, 363);
- Add_Goto (Table.States (589), 323, 114);
- Table.States (589).Kernel := To_Vector ((0 => (113, 21, 2,
False)));
- Table.States (589).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 218, 0)));
- Table.States (590).Action_List.Set_Capacity (46);
- Add_Action (Table.States (590), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (113, 1), 5, accept_statement_1'Access, null);
- Table.States (590).Kernel := To_Vector ((0 => (113, 96, 0,
False)));
- Table.States (590).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 113, 5)));
- Table.States (591).Action_List.Set_Capacity (17);
- Add_Action (Table.States (591), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 79, 83, 87, 96), (275,
+ Table.States (592).Kernel := To_Vector ((0 => (310, 97, 0,
False)));
+ Table.States (592).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 310, 4)));
+ Table.States (593).Action_List.Set_Capacity (25);
+ Add_Action (Table.States (593), 4, 1);
+ Add_Action (Table.States (593), 5, 2);
+ Add_Action (Table.States (593), 13, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (593), 15, 3);
+ Add_Action (Table.States (593), 17, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (593), 18, 4);
+ Add_Action (Table.States (593), 24, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (593), 26, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (593), 27, 5);
+ Add_Action (Table.States (593), 28, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (593), 31, 9);
+ Add_Action (Table.States (593), 32, 10);
+ Add_Action (Table.States (593), 37, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (593), 41, 13);
+ Add_Action (Table.States (593), 48, 16);
+ Add_Action (Table.States (593), 52, 20);
+ Add_Action (Table.States (593), 57, 21);
+ Add_Action (Table.States (593), 58, 22);
+ Add_Action (Table.States (593), 61, 24);
+ Add_Action (Table.States (593), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (593), 79, 31);
+ Add_Action (Table.States (593), 94, 32);
+ Add_Action (Table.States (593), 105, 361);
+ Add_Action (Table.States (593), 106, 34);
+ Add_Action (Table.States (593), 107, 35);
+ Table.States (593).Goto_List.Set_Capacity (32);
+ Add_Goto (Table.States (593), 114, 37);
+ Add_Goto (Table.States (593), 124, 39);
+ Add_Goto (Table.States (593), 127, 40);
+ Add_Goto (Table.States (593), 129, 42);
+ Add_Goto (Table.States (593), 132, 43);
+ Add_Goto (Table.States (593), 133, 44);
+ Add_Goto (Table.States (593), 134, 45);
+ Add_Goto (Table.States (593), 140, 48);
+ Add_Goto (Table.States (593), 152, 51);
+ Add_Goto (Table.States (593), 153, 52);
+ Add_Goto (Table.States (593), 162, 54);
+ Add_Goto (Table.States (593), 191, 58);
+ Add_Goto (Table.States (593), 197, 60);
+ Add_Goto (Table.States (593), 218, 69);
+ Add_Goto (Table.States (593), 219, 767);
+ Add_Goto (Table.States (593), 223, 71);
+ Add_Goto (Table.States (593), 233, 73);
+ Add_Goto (Table.States (593), 240, 74);
+ Add_Goto (Table.States (593), 258, 84);
+ Add_Goto (Table.States (593), 262, 87);
+ Add_Goto (Table.States (593), 273, 93);
+ Add_Goto (Table.States (593), 277, 94);
+ Add_Goto (Table.States (593), 291, 97);
+ Add_Goto (Table.States (593), 294, 98);
+ Add_Goto (Table.States (593), 295, 99);
+ Add_Goto (Table.States (593), 299, 100);
+ Add_Goto (Table.States (593), 300, 362);
+ Add_Goto (Table.States (593), 301, 391);
+ Add_Goto (Table.States (593), 303, 101);
+ Add_Goto (Table.States (593), 304, 102);
+ Add_Goto (Table.States (593), 307, 364);
+ Add_Goto (Table.States (593), 324, 115);
+ Table.States (593).Kernel := To_Vector ((0 => (114, 21, 2,
False)));
+ Table.States (593).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 219, 0)));
+ Table.States (594).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (594), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (114, 1), 5, accept_statement_1'Access, null);
+ Table.States (594).Kernel := To_Vector ((0 => (114, 97, 0,
False)));
+ Table.States (594).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 114, 5)));
+ Table.States (595).Action_List.Set_Capacity (17);
+ Add_Action (Table.States (595), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 80, 84, 88, 97), (276,
0), 4, raise_expression_0'Access, null);
- Table.States (591).Kernel := To_Vector ((0 => (275, 192, 0,
True)));
- Table.States (591).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 275, 4)));
- Table.States (591).Minimal_Complete_Actions_Recursive := True;
- Table.States (592).Action_List.Set_Capacity (1);
- Add_Action (Table.States (592), 72, 762);
- Table.States (592).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (592), 137, 763);
- Add_Goto (Table.States (592), 138, 764);
- Table.States (592).Kernel := To_Vector ((0 => (136, 35, 2,
False)));
- Table.States (592).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 72, 762)));
- Table.States (593).Action_List.Set_Capacity (1);
- Add_Action (Table.States (593), 87, 765);
- Table.States (593).Kernel := To_Vector ((0 => (273, 230, 1,
False)));
- Table.States (593).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 87, 765)));
- Table.States (594).Action_List.Set_Capacity (15);
- Add_Action (Table.States (594), 3, 121);
- Add_Action (Table.States (594), 22, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (594), 23, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (594), 39, 122);
- Add_Action (Table.States (594), 40, 123);
- Add_Action (Table.States (594), 41, 124);
- Add_Action (Table.States (594), 52, 125);
- Add_Action (Table.States (594), 76, 126);
- Add_Action (Table.States (594), 77, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (594), 94, 127);
- Add_Action (Table.States (594), 95, 128);
- Add_Action (Table.States (594), 103, 129);
- Add_Action (Table.States (594), 104, 119);
- Add_Action (Table.States (594), 105, 33);
- Add_Action (Table.States (594), 106, 34);
- Table.States (594).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (594), 117, 130);
- Add_Goto (Table.States (594), 128, 41);
- Add_Goto (Table.States (594), 191, 131);
- Add_Goto (Table.States (594), 192, 766);
- Add_Goto (Table.States (594), 197, 133);
- Add_Goto (Table.States (594), 239, 134);
- Add_Goto (Table.States (594), 258, 135);
- Add_Goto (Table.States (594), 272, 92);
- Add_Goto (Table.States (594), 275, 136);
- Add_Goto (Table.States (594), 282, 137);
- Add_Goto (Table.States (594), 283, 138);
- Add_Goto (Table.States (594), 284, 139);
- Add_Goto (Table.States (594), 285, 140);
- Add_Goto (Table.States (594), 286, 141);
- Add_Goto (Table.States (594), 287, 142);
- Add_Goto (Table.States (594), 293, 97);
- Add_Goto (Table.States (594), 301, 143);
- Add_Goto (Table.States (594), 320, 144);
- Add_Goto (Table.States (594), 321, 145);
- Add_Goto (Table.States (594), 330, 146);
- Table.States (594).Kernel := To_Vector (((221, 68, 3, False),
(221, 68, 1, False), (221, 68, 2, False),
- (221, 68, 0, False)));
- Table.States (594).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (595).Action_List.Set_Capacity (6);
- Add_Action (Table.States (595), 76, 235);
- Add_Action (Table.States (595), 79, Reduce, (165, 1), 3, null,
null);
- Add_Action (Table.States (595), 84, 237);
- Add_Action (Table.States (595), 87, Reduce, (165, 1), 3, null,
null);
- Add_Action (Table.States (595), 101, 239);
- Add_Action (Table.States (595), 102, 240);
- Table.States (595).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (595), 115, 241);
- Add_Goto (Table.States (595), 322, 242);
- Table.States (595).Kernel := To_Vector (((128, 239, 2, True),
(165, 239, 0, False), (239, 239, 5, True),
- (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (595).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 165, 3)));
- Table.States (596).Action_List.Set_Capacity (63);
- Add_Action (Table.States (596), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
- 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
- 88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104,
105, 106), (117, 2), 4, null, null);
- Table.States (596).Kernel := To_Vector ((0 => (117, 77, 0,
False)));
- Table.States (596).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 117, 4)));
- Table.States (597).Action_List.Set_Capacity (4);
- Add_Action (Table.States (597), (35, 77, 83, 96), (124, 1), 3,
null, null);
- Table.States (597).Kernel := To_Vector ((0 => (124, 80, 0,
False)));
- Table.States (597).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 124, 3)));
- Table.States (598).Action_List.Set_Capacity (4);
- Add_Action (Table.States (598), (35, 77, 83, 96), (124, 0), 3,
association_opt_0'Access, null);
- Table.States (598).Kernel := To_Vector ((0 => (124, 192, 0,
False)));
- Table.States (598).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 124, 3)));
- Table.States (599).Action_List.Set_Capacity (4);
- Add_Action (Table.States (599), (35, 77, 83, 96), (125, 0), 3,
null, null);
- Table.States (599).Kernel := To_Vector ((0 => (125, 124, 0,
True)));
- Table.States (599).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 125, 3)));
- Table.States (599).Minimal_Complete_Actions_Recursive := True;
- Table.States (600).Action_List.Set_Capacity (2);
- Add_Action (Table.States (600), (79, 87), (166, 0), 3, null, null);
- Table.States (600).Kernel := To_Vector ((0 => (166, 165, 0,
True)));
+ Table.States (595).Kernel := To_Vector ((0 => (276, 193, 0,
True)));
+ Table.States (595).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 276, 4)));
+ Table.States (595).Minimal_Complete_Actions_Recursive := True;
+ Table.States (596).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (596), 72, 768);
+ Table.States (596).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (596), 138, 769);
+ Add_Goto (Table.States (596), 139, 770);
+ Table.States (596).Kernel := To_Vector ((0 => (137, 35, 2,
False)));
+ Table.States (596).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 72, 768)));
+ Table.States (597).Action_List.Set_Capacity (16);
+ Add_Action (Table.States (597), 3, 122);
+ Add_Action (Table.States (597), 39, 123);
+ Add_Action (Table.States (597), 40, 262);
+ Add_Action (Table.States (597), 41, 125);
+ Add_Action (Table.States (597), 44, 264);
+ Add_Action (Table.States (597), 52, 126);
+ Add_Action (Table.States (597), 76, 127);
+ Add_Action (Table.States (597), 79, 31);
+ Add_Action (Table.States (597), 80, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (597), 88, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (597), 95, 128);
+ Add_Action (Table.States (597), 96, 129);
+ Add_Action (Table.States (597), 104, 130);
+ Add_Action (Table.States (597), 105, 120);
+ Add_Action (Table.States (597), 106, 34);
+ Add_Action (Table.States (597), 107, 35);
+ Table.States (597).Goto_List.Set_Capacity (22);
+ Add_Goto (Table.States (597), 118, 131);
+ Add_Goto (Table.States (597), 129, 42);
+ Add_Goto (Table.States (597), 166, 270);
+ Add_Goto (Table.States (597), 167, 771);
+ Add_Goto (Table.States (597), 192, 606);
+ Add_Goto (Table.States (597), 198, 134);
+ Add_Goto (Table.States (597), 240, 275);
+ Add_Goto (Table.States (597), 259, 136);
+ Add_Goto (Table.States (597), 273, 93);
+ Add_Goto (Table.States (597), 276, 137);
+ Add_Goto (Table.States (597), 278, 277);
+ Add_Goto (Table.States (597), 283, 138);
+ Add_Goto (Table.States (597), 284, 139);
+ Add_Goto (Table.States (597), 285, 140);
+ Add_Goto (Table.States (597), 286, 141);
+ Add_Goto (Table.States (597), 287, 142);
+ Add_Goto (Table.States (597), 288, 143);
+ Add_Goto (Table.States (597), 294, 98);
+ Add_Goto (Table.States (597), 302, 278);
+ Add_Goto (Table.States (597), 321, 145);
+ Add_Goto (Table.States (597), 322, 146);
+ Add_Goto (Table.States (597), 331, 147);
+ Table.States (597).Kernel := To_Vector ((0 => (125, 33, 2,
False)));
+ Table.States (597).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 167, 0)));
+ Table.States (598).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (598), 88, 772);
+ Table.States (598).Kernel := To_Vector ((0 => (274, 231, 1,
False)));
+ Table.States (598).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 88, 772)));
+ Table.States (599).Action_List.Set_Capacity (16);
+ Add_Action (Table.States (599), 3, 122);
+ Add_Action (Table.States (599), 22, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (599), 23, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (599), 39, 123);
+ Add_Action (Table.States (599), 40, 124);
+ Add_Action (Table.States (599), 41, 125);
+ Add_Action (Table.States (599), 52, 126);
+ Add_Action (Table.States (599), 76, 127);
+ Add_Action (Table.States (599), 77, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (599), 79, 31);
+ Add_Action (Table.States (599), 95, 128);
+ Add_Action (Table.States (599), 96, 129);
+ Add_Action (Table.States (599), 104, 130);
+ Add_Action (Table.States (599), 105, 120);
+ Add_Action (Table.States (599), 106, 34);
+ Add_Action (Table.States (599), 107, 35);
+ Table.States (599).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (599), 118, 131);
+ Add_Goto (Table.States (599), 129, 42);
+ Add_Goto (Table.States (599), 192, 132);
+ Add_Goto (Table.States (599), 193, 773);
+ Add_Goto (Table.States (599), 198, 134);
+ Add_Goto (Table.States (599), 240, 135);
+ Add_Goto (Table.States (599), 259, 136);
+ Add_Goto (Table.States (599), 273, 93);
+ Add_Goto (Table.States (599), 276, 137);
+ Add_Goto (Table.States (599), 283, 138);
+ Add_Goto (Table.States (599), 284, 139);
+ Add_Goto (Table.States (599), 285, 140);
+ Add_Goto (Table.States (599), 286, 141);
+ Add_Goto (Table.States (599), 287, 142);
+ Add_Goto (Table.States (599), 288, 143);
+ Add_Goto (Table.States (599), 294, 98);
+ Add_Goto (Table.States (599), 302, 144);
+ Add_Goto (Table.States (599), 321, 145);
+ Add_Goto (Table.States (599), 322, 146);
+ Add_Goto (Table.States (599), 331, 147);
+ Table.States (599).Kernel := To_Vector (((222, 68, 3, False),
(222, 68, 1, False), (222, 68, 2, False),
+ (222, 68, 0, False)));
+ Table.States (599).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (600).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (600), 76, 236);
+ Add_Action (Table.States (600), 80, Reduce, (166, 1), 3, null,
null);
+ Add_Action (Table.States (600), 85, 238);
+ Add_Action (Table.States (600), 88, Reduce, (166, 1), 3, null,
null);
+ Add_Action (Table.States (600), 102, 240);
+ Add_Action (Table.States (600), 103, 241);
+ Table.States (600).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (600), 116, 242);
+ Add_Goto (Table.States (600), 323, 243);
+ Table.States (600).Kernel := To_Vector (((129, 240, 2, True),
(166, 240, 0, False), (240, 240, 5, True),
+ (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
Table.States (600).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 166, 3)));
- Table.States (600).Minimal_Complete_Actions_Recursive := True;
- Table.States (601).Action_List.Set_Capacity (2);
- Add_Action (Table.States (601), (79, 87), (165, 0), 1, null, null);
- Table.States (601).Kernel := To_Vector ((0 => (165, 191, 0,
False)));
- Table.States (601).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 165, 1)));
+ Table.States (601).Action_List.Set_Capacity (64);
+ Add_Action (Table.States (601), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+ 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
105, 106, 107), (118, 2), 4, null, null);
+ Table.States (601).Kernel := To_Vector ((0 => (118, 77, 0,
False)));
+ Table.States (601).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 118, 4)));
Table.States (602).Action_List.Set_Capacity (4);
- Add_Action (Table.States (602), (35, 77, 83, 96), (124, 3), 3,
association_opt_3'Access, null);
- Table.States (602).Kernel := To_Vector ((0 => (124, 80, 0,
False)));
- Table.States (602).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 124, 3)));
+ Add_Action (Table.States (602), (35, 77, 84, 97), (125, 1), 3,
null, null);
+ Table.States (602).Kernel := To_Vector ((0 => (125, 81, 0,
False)));
+ Table.States (602).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 125, 3)));
Table.States (603).Action_List.Set_Capacity (4);
- Add_Action (Table.States (603), (35, 77, 83, 96), (124, 2), 3,
association_opt_2'Access, null);
- Table.States (603).Kernel := To_Vector ((0 => (124, 192, 0,
False)));
- Table.States (603).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 124, 3)));
- Table.States (604).Action_List.Set_Capacity (25);
- Add_Action (Table.States (604), 10, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (604), 33, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (604), 38, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (604), 40, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (604), 43, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (604), 54, 767);
- Add_Action (Table.States (604), 55, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (604), 75, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (604), 77, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (604), 78, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (604), 79, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (604), 83, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (604), 85, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (604), 86, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (604), 87, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (604), 88, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (604), 89, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (604), 91, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (604), 92, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (604), 94, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (604), 95, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (604), 97, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (604), 98, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (604), 99, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (604), 100, Reduce, (258, 1), 1, null,
null);
- Table.States (604).Kernel := To_Vector (((117, 41, 2, False),
(258, 41, 0, False)));
- Table.States (604).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 258, 1)));
- end Subr_11;
- procedure Subr_12
- is begin
+ Add_Action (Table.States (603), (35, 77, 84, 97), (125, 0), 3,
association_opt_0'Access, null);
+ Table.States (603).Kernel := To_Vector ((0 => (125, 193, 0,
False)));
+ Table.States (603).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 125, 3)));
+ Table.States (604).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (604), (35, 77, 84, 97), (126, 0), 3,
null, null);
+ Table.States (604).Kernel := To_Vector ((0 => (126, 125, 0,
True)));
+ Table.States (604).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 126, 3)));
+ Table.States (604).Minimal_Complete_Actions_Recursive := True;
Table.States (605).Action_List.Set_Capacity (2);
- Add_Action (Table.States (605), 77, 768);
- Add_Action (Table.States (605), 83, 443);
- Table.States (605).Kernel := To_Vector (((117, 125, 1, False),
(125, 125, 1, True)));
- Table.States (605).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 768)));
- Table.States (606).Action_List.Set_Capacity (20);
- Add_Action (Table.States (606), 10, Reduce, (277, 1), 3, null,
null);
- Add_Action (Table.States (606), 20, Reduce, (277, 1), 3, null,
null);
- Add_Action (Table.States (606), 21, Reduce, (277, 1), 3, null,
null);
- Add_Action (Table.States (606), 22, Reduce, (277, 1), 3, null,
null);
- Add_Action (Table.States (606), 23, Reduce, (277, 1), 3, null,
null);
- Add_Action (Table.States (606), 35, Reduce, (277, 1), 3, null,
null);
- Add_Action (Table.States (606), 37, Reduce, (277, 1), 3, null,
null);
- Add_Action (Table.States (606), 42, Reduce, (277, 1), 3, null,
null);
- Add_Action (Table.States (606), 43, Reduce, (277, 1), 3, null,
null);
- Add_Action (Table.States (606), 53, Reduce, (277, 1), 3, null,
null);
- Add_Action (Table.States (606), 68, Reduce, (277, 1), 3, null,
null);
- Add_Action (Table.States (606), 74, Reduce, (277, 1), 3, null,
null);
- Add_Action (Table.States (606), 75, Reduce, (277, 1), 3, null,
null);
- Add_Action (Table.States (606), 76, 769);
- Add_Action (Table.States (606), 77, Reduce, (277, 1), 3, null,
null);
- Add_Action (Table.States (606), 79, Reduce, (277, 1), 3, null,
null);
- Add_Action (Table.States (606), 82, Reduce, (277, 1), 3, null,
null);
- Add_Action (Table.States (606), 83, Reduce, (277, 1), 3, null,
null);
- Add_Action (Table.States (606), 87, Reduce, (277, 1), 3, null,
null);
- Add_Action (Table.States (606), 96, Reduce, (277, 1), 3, null,
null);
- Table.States (606).Kernel := To_Vector (((277, 53, 2, False),
(277, 53, 0, False)));
- Table.States (606).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 277, 3)));
- Table.States (607).Action_List.Set_Capacity (19);
- Add_Action (Table.States (607), (10, 20, 21, 22, 23, 35, 37, 42,
43, 53, 68, 74, 75, 77, 79, 82, 83, 87,
- 96), (277, 2), 3, null, null);
- Table.States (607).Kernel := To_Vector ((0 => (277, 301, 0,
False)));
- Table.States (607).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 277, 3)));
- Table.States (608).Action_List.Set_Capacity (2);
- Add_Action (Table.States (608), 79, 445);
- Add_Action (Table.States (608), 87, 770);
- Table.States (608).Kernel := To_Vector (((140, 166, 1, False),
(166, 166, 2, True)));
- Table.States (608).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 87, 770)));
- Table.States (609).Action_List.Set_Capacity (1);
- Add_Action (Table.States (609), 15, 771);
- Table.States (609).Kernel := To_Vector ((0 => (139, 24, 2,
False)));
- Table.States (609).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 15, 771)));
- Table.States (610).Action_List.Set_Capacity (2);
- Add_Action (Table.States (610), (24, 72), (141, 0), 2,
case_statement_alternative_list_0'Access, null);
- Table.States (610).Kernel := To_Vector ((0 => (141, 140, 0,
True)));
- Table.States (610).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 141, 2)));
- Table.States (610).Minimal_Complete_Actions_Recursive := True;
- Table.States (611).Action_List.Set_Capacity (17);
- Add_Action (Table.States (611), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 79, 83, 87, 96), (283,
+ Add_Action (Table.States (605), (80, 88), (167, 0), 3, null, null);
+ Table.States (605).Kernel := To_Vector ((0 => (167, 166, 0,
True)));
+ Table.States (605).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 167, 3)));
+ Table.States (605).Minimal_Complete_Actions_Recursive := True;
+ Table.States (606).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (606), (80, 88), (166, 0), 1, null, null);
+ Table.States (606).Kernel := To_Vector ((0 => (166, 192, 0,
False)));
+ Table.States (606).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 166, 1)));
+ Table.States (607).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (607), (35, 77, 84, 97), (125, 3), 3,
association_opt_3'Access, null);
+ Table.States (607).Kernel := To_Vector ((0 => (125, 81, 0,
False)));
+ Table.States (607).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 125, 3)));
+ Table.States (608).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (608), (35, 77, 84, 97), (125, 2), 3,
association_opt_2'Access, null);
+ Table.States (608).Kernel := To_Vector ((0 => (125, 193, 0,
False)));
+ Table.States (608).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 125, 3)));
+ Table.States (609).Action_List.Set_Capacity (19);
+ Add_Action (Table.States (609), 3, 122);
+ Add_Action (Table.States (609), 28, 517);
+ Add_Action (Table.States (609), 39, 123);
+ Add_Action (Table.States (609), 40, 262);
+ Add_Action (Table.States (609), 41, 125);
+ Add_Action (Table.States (609), 44, 264);
+ Add_Action (Table.States (609), 52, 126);
+ Add_Action (Table.States (609), 76, 127);
+ Add_Action (Table.States (609), 77, Reduce, (125, 6), 0, null,
null);
+ Add_Action (Table.States (609), 79, 31);
+ Add_Action (Table.States (609), 80, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (609), 84, Reduce, (125, 6), 0, null,
null);
+ Add_Action (Table.States (609), 88, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (609), 95, 128);
+ Add_Action (Table.States (609), 96, 129);
+ Add_Action (Table.States (609), 104, 130);
+ Add_Action (Table.States (609), 105, 120);
+ Add_Action (Table.States (609), 106, 34);
+ Add_Action (Table.States (609), 107, 265);
+ Table.States (609).Goto_List.Set_Capacity (24);
+ Add_Goto (Table.States (609), 118, 131);
+ Add_Goto (Table.States (609), 125, 266);
+ Add_Goto (Table.States (609), 126, 774);
+ Add_Goto (Table.States (609), 129, 42);
+ Add_Goto (Table.States (609), 166, 270);
+ Add_Goto (Table.States (609), 167, 271);
+ Add_Goto (Table.States (609), 192, 409);
+ Add_Goto (Table.States (609), 198, 134);
+ Add_Goto (Table.States (609), 240, 275);
+ Add_Goto (Table.States (609), 259, 136);
+ Add_Goto (Table.States (609), 273, 93);
+ Add_Goto (Table.States (609), 276, 137);
+ Add_Goto (Table.States (609), 278, 277);
+ Add_Goto (Table.States (609), 283, 138);
+ Add_Goto (Table.States (609), 284, 139);
+ Add_Goto (Table.States (609), 285, 140);
+ Add_Goto (Table.States (609), 286, 141);
+ Add_Goto (Table.States (609), 287, 142);
+ Add_Goto (Table.States (609), 288, 143);
+ Add_Goto (Table.States (609), 294, 98);
+ Add_Goto (Table.States (609), 302, 278);
+ Add_Goto (Table.States (609), 321, 145);
+ Add_Goto (Table.States (609), 322, 146);
+ Add_Goto (Table.States (609), 331, 147);
+ Table.States (609).Kernel := To_Vector ((0 => (118, 19, 1,
False)));
+ Table.States (609).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 126, 0)));
+ Table.States (610).Action_List.Set_Capacity (25);
+ Add_Action (Table.States (610), 10, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (610), 33, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (610), 38, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (610), 40, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (610), 43, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (610), 54, 775);
+ Add_Action (Table.States (610), 55, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (610), 75, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (610), 77, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (610), 78, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (610), 80, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (610), 84, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (610), 86, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (610), 87, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (610), 88, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (610), 89, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (610), 90, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (610), 92, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (610), 93, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (610), 95, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (610), 96, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (610), 98, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (610), 99, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (610), 100, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (610), 101, Reduce, (259, 1), 1, null,
null);
+ Table.States (610).Kernel := To_Vector (((118, 41, 2, False),
(259, 41, 0, False)));
+ Table.States (610).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 259, 1)));
+ Table.States (611).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (611), 77, 776);
+ Add_Action (Table.States (611), 84, 445);
+ Table.States (611).Kernel := To_Vector (((118, 126, 1, False),
(126, 126, 1, True)));
+ Table.States (611).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 776)));
+ Table.States (612).Action_List.Set_Capacity (20);
+ Add_Action (Table.States (612), 10, Reduce, (278, 1), 3, null,
null);
+ Add_Action (Table.States (612), 20, Reduce, (278, 1), 3, null,
null);
+ Add_Action (Table.States (612), 21, Reduce, (278, 1), 3, null,
null);
+ Add_Action (Table.States (612), 22, Reduce, (278, 1), 3, null,
null);
+ Add_Action (Table.States (612), 23, Reduce, (278, 1), 3, null,
null);
+ Add_Action (Table.States (612), 35, Reduce, (278, 1), 3, null,
null);
+ Add_Action (Table.States (612), 37, Reduce, (278, 1), 3, null,
null);
+ Add_Action (Table.States (612), 42, Reduce, (278, 1), 3, null,
null);
+ Add_Action (Table.States (612), 43, Reduce, (278, 1), 3, null,
null);
+ Add_Action (Table.States (612), 53, Reduce, (278, 1), 3, null,
null);
+ Add_Action (Table.States (612), 68, Reduce, (278, 1), 3, null,
null);
+ Add_Action (Table.States (612), 74, Reduce, (278, 1), 3, null,
null);
+ Add_Action (Table.States (612), 75, Reduce, (278, 1), 3, null,
null);
+ Add_Action (Table.States (612), 76, 777);
+ Add_Action (Table.States (612), 77, Reduce, (278, 1), 3, null,
null);
+ Add_Action (Table.States (612), 80, Reduce, (278, 1), 3, null,
null);
+ Add_Action (Table.States (612), 83, Reduce, (278, 1), 3, null,
null);
+ Add_Action (Table.States (612), 84, Reduce, (278, 1), 3, null,
null);
+ Add_Action (Table.States (612), 88, Reduce, (278, 1), 3, null,
null);
+ Add_Action (Table.States (612), 97, Reduce, (278, 1), 3, null,
null);
+ Table.States (612).Kernel := To_Vector (((278, 53, 2, False),
(278, 53, 0, False)));
+ Table.States (612).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 278, 3)));
+ Table.States (613).Action_List.Set_Capacity (19);
+ Add_Action (Table.States (613), (10, 20, 21, 22, 23, 35, 37, 42,
43, 53, 68, 74, 75, 77, 80, 83, 84, 88,
+ 97), (278, 2), 3, null, null);
+ Table.States (613).Kernel := To_Vector ((0 => (278, 302, 0,
False)));
+ Table.States (613).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 278, 3)));
+ Table.States (614).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (614), 80, 447);
+ Add_Action (Table.States (614), 88, 778);
+ Table.States (614).Kernel := To_Vector (((141, 167, 1, False),
(167, 167, 2, True)));
+ Table.States (614).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 88, 778)));
+ Table.States (615).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (615), 15, 779);
+ Table.States (615).Kernel := To_Vector ((0 => (140, 24, 2,
False)));
+ Table.States (615).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 15, 779)));
+ Table.States (616).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (616), (24, 72), (142, 0), 2,
case_statement_alternative_list_0'Access, null);
+ Table.States (616).Kernel := To_Vector ((0 => (142, 141, 0,
True)));
+ Table.States (616).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 142, 2)));
+ Table.States (616).Minimal_Complete_Actions_Recursive := True;
+ Table.States (617).Action_List.Set_Capacity (17);
+ Add_Action (Table.States (617), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 80, 84, 88, 97), (284,
0), 4, null, null);
- Table.States (611).Kernel := To_Vector ((0 => (283, 287, 0,
True)));
- Table.States (611).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 283, 4)));
- Table.States (611).Minimal_Complete_Actions_Recursive := True;
- Table.States (612).Action_List.Set_Capacity (17);
- Add_Action (Table.States (612), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 79, 83, 87, 96), (285,
+ Table.States (617).Kernel := To_Vector ((0 => (284, 288, 0,
True)));
+ Table.States (617).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 284, 4)));
+ Table.States (617).Minimal_Complete_Actions_Recursive := True;
+ Table.States (618).Action_List.Set_Capacity (17);
+ Add_Action (Table.States (618), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 80, 84, 88, 97), (286,
0), 4, null, null);
- Table.States (612).Kernel := To_Vector ((0 => (285, 287, 0,
True)));
- Table.States (612).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 285, 4)));
- Table.States (612).Minimal_Complete_Actions_Recursive := True;
- Table.States (613).Action_List.Set_Capacity (17);
- Add_Action (Table.States (613), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 79, 83, 87, 96), (283,
+ Table.States (618).Kernel := To_Vector ((0 => (286, 288, 0,
True)));
+ Table.States (618).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 286, 4)));
+ Table.States (618).Minimal_Complete_Actions_Recursive := True;
+ Table.States (619).Action_List.Set_Capacity (17);
+ Add_Action (Table.States (619), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 80, 84, 88, 97), (284,
1), 4, null, null);
- Table.States (613).Kernel := To_Vector ((0 => (283, 287, 0,
True)));
- Table.States (613).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 283, 4)));
- Table.States (613).Minimal_Complete_Actions_Recursive := True;
- Table.States (614).Action_List.Set_Capacity (17);
- Add_Action (Table.States (614), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 79, 83, 87, 96), (285,
+ Table.States (619).Kernel := To_Vector ((0 => (284, 288, 0,
True)));
+ Table.States (619).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 284, 4)));
+ Table.States (619).Minimal_Complete_Actions_Recursive := True;
+ Table.States (620).Action_List.Set_Capacity (17);
+ Add_Action (Table.States (620), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 80, 84, 88, 97), (286,
1), 4, null, null);
- Table.States (614).Kernel := To_Vector ((0 => (285, 287, 0,
True)));
- Table.States (614).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 285, 4)));
- Table.States (614).Minimal_Complete_Actions_Recursive := True;
- Table.States (615).Action_List.Set_Capacity (11);
- Add_Action (Table.States (615), 3, 121);
- Add_Action (Table.States (615), 39, 122);
- Add_Action (Table.States (615), 40, 123);
- Add_Action (Table.States (615), 41, 124);
- Add_Action (Table.States (615), 76, 126);
- Add_Action (Table.States (615), 94, 127);
- Add_Action (Table.States (615), 95, 128);
- Add_Action (Table.States (615), 103, 129);
- Add_Action (Table.States (615), 104, 119);
- Add_Action (Table.States (615), 105, 33);
- Add_Action (Table.States (615), 106, 34);
- Table.States (615).Goto_List.Set_Capacity (13);
- Add_Goto (Table.States (615), 117, 130);
- Add_Goto (Table.States (615), 128, 41);
- Add_Goto (Table.States (615), 197, 133);
- Add_Goto (Table.States (615), 234, 772);
- Add_Goto (Table.States (615), 239, 274);
- Add_Goto (Table.States (615), 258, 135);
- Add_Goto (Table.States (615), 272, 92);
- Add_Goto (Table.States (615), 277, 466);
- Add_Goto (Table.States (615), 293, 97);
- Add_Goto (Table.States (615), 301, 467);
- Add_Goto (Table.States (615), 320, 144);
- Add_Goto (Table.States (615), 321, 145);
- Add_Goto (Table.States (615), 330, 146);
- Table.States (615).Kernel := To_Vector ((0 => (233, 79, 1, True)));
- Table.States (615).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
- Table.States (615).Minimal_Complete_Actions_Recursive := True;
- Table.States (616).Action_List.Set_Capacity (17);
- Add_Action (Table.States (616), 10, Reduce, (287, 0), 4, null,
null);
- Add_Action (Table.States (616), 20, Reduce, (287, 0), 4, null,
null);
- Add_Action (Table.States (616), 21, Reduce, (287, 0), 4, null,
null);
- Add_Action (Table.States (616), 22, Reduce, (287, 0), 4, null,
null);
- Add_Action (Table.States (616), 23, Reduce, (287, 0), 4, null,
null);
- Add_Action (Table.States (616), 35, Reduce, (287, 0), 4, null,
null);
- Add_Action (Table.States (616), 37, Reduce, (287, 0), 4, null,
null);
- Add_Action (Table.States (616), 43, Reduce, (287, 0), 4, null,
null);
- Add_Action (Table.States (616), 53, Reduce, (287, 0), 4, null,
null);
- Add_Action (Table.States (616), 68, Reduce, (287, 0), 4, null,
null);
- Add_Action (Table.States (616), 74, Reduce, (287, 0), 4, null,
null);
- Add_Action (Table.States (616), 75, Reduce, (287, 0), 4, null,
null);
- Add_Action (Table.States (616), 77, Reduce, (287, 0), 4, null,
null);
- Add_Action (Table.States (616), 79, 615);
- Add_Conflict (Table.States (616), 79, (287, 0), 4, null, null);
- Add_Action (Table.States (616), 83, Reduce, (287, 0), 4, null,
null);
- Add_Action (Table.States (616), 87, Reduce, (287, 0), 4, null,
null);
- Add_Action (Table.States (616), 96, Reduce, (287, 0), 4, null,
null);
- Table.States (616).Kernel := To_Vector (((233, 233, 2, True),
(287, 233, 0, False)));
- Table.States (616).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 287, 4)));
- Table.States (617).Action_List.Set_Capacity (46);
- Add_Action (Table.States (617), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (190, 0), 5, exit_statement_0'Access, null);
- Table.States (617).Kernel := To_Vector ((0 => (190, 96, 0,
False)));
- Table.States (617).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 190, 5)));
- Table.States (618).Action_List.Set_Capacity (11);
- Add_Action (Table.States (618), 38, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (618), 55, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (618), 78, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (618), 85, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (618), 94, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (618), 95, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (618), 97, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (618), 99, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (618), 104, 119);
- Add_Action (Table.States (618), 105, 33);
- Add_Action (Table.States (618), 106, 34);
- Table.States (618).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (618), 128, 41);
- Add_Goto (Table.States (618), 239, 773);
- Add_Goto (Table.States (618), 272, 92);
- Add_Goto (Table.States (618), 293, 97);
- Table.States (618).Kernel := To_Vector (((258, 41, 0, False),
(314, 41, 5, False), (314, 41, 1, False)));
- Table.States (618).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 258, 1)));
- Table.States (619).Action_List.Set_Capacity (2);
- Add_Action (Table.States (619), (37, 87), (230, 2), 4,
iterator_specification_2'Access, null);
- Table.States (619).Kernel := To_Vector ((0 => (230, 167, 0,
False)));
- Table.States (619).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 230, 4)));
- Table.States (620).Action_List.Set_Capacity (11);
- Add_Action (Table.States (620), 3, 121);
- Add_Action (Table.States (620), 39, 122);
- Add_Action (Table.States (620), 40, 123);
- Add_Action (Table.States (620), 41, 124);
- Add_Action (Table.States (620), 76, 126);
- Add_Action (Table.States (620), 94, 127);
- Add_Action (Table.States (620), 95, 128);
- Add_Action (Table.States (620), 103, 129);
- Add_Action (Table.States (620), 104, 119);
- Add_Action (Table.States (620), 105, 33);
- Add_Action (Table.States (620), 106, 34);
- Table.States (620).Goto_List.Set_Capacity (12);
- Add_Goto (Table.States (620), 117, 130);
- Add_Goto (Table.States (620), 128, 41);
- Add_Goto (Table.States (620), 197, 133);
- Add_Goto (Table.States (620), 239, 274);
- Add_Goto (Table.States (620), 258, 135);
- Add_Goto (Table.States (620), 272, 92);
- Add_Goto (Table.States (620), 277, 774);
- Add_Goto (Table.States (620), 293, 97);
- Add_Goto (Table.States (620), 301, 479);
- Add_Goto (Table.States (620), 320, 144);
- Add_Goto (Table.States (620), 321, 145);
- Add_Goto (Table.States (620), 330, 146);
- Table.States (620).Kernel := To_Vector ((0 => (155, 53, 3,
False)));
- Table.States (620).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (621).Action_List.Set_Capacity (20);
- Add_Action (Table.States (621), 3, 121);
- Add_Action (Table.States (621), 15, 258);
- Add_Action (Table.States (621), 28, 259);
- Add_Action (Table.States (621), 32, 260);
- Add_Action (Table.States (621), 39, 122);
- Add_Action (Table.States (621), 40, 775);
- Add_Action (Table.States (621), 41, 124);
- Add_Action (Table.States (621), 44, 263);
- Add_Action (Table.States (621), 52, 125);
- Add_Action (Table.States (621), 76, 126);
- Add_Action (Table.States (621), 77, Reduce, (124, 5), 0, null,
null);
- Add_Action (Table.States (621), 79, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (621), 83, Reduce, (124, 5), 0, null,
null);
- Add_Action (Table.States (621), 87, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (621), 94, 127);
+ Table.States (620).Kernel := To_Vector ((0 => (286, 288, 0,
True)));
+ Table.States (620).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 286, 4)));
+ Table.States (620).Minimal_Complete_Actions_Recursive := True;
+ Table.States (621).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (621), 3, 122);
+ Add_Action (Table.States (621), 39, 123);
+ Add_Action (Table.States (621), 40, 124);
+ Add_Action (Table.States (621), 41, 125);
+ Add_Action (Table.States (621), 76, 127);
+ Add_Action (Table.States (621), 79, 31);
Add_Action (Table.States (621), 95, 128);
- Add_Action (Table.States (621), 103, 129);
- Add_Action (Table.States (621), 104, 119);
- Add_Action (Table.States (621), 105, 33);
- Add_Action (Table.States (621), 106, 264);
- Table.States (621).Goto_List.Set_Capacity (32);
- Add_Goto (Table.States (621), 117, 130);
- Add_Goto (Table.States (621), 124, 265);
- Add_Goto (Table.States (621), 125, 406);
- Add_Goto (Table.States (621), 128, 41);
- Add_Goto (Table.States (621), 136, 267);
- Add_Goto (Table.States (621), 153, 407);
- Add_Goto (Table.States (621), 165, 269);
- Add_Goto (Table.States (621), 166, 270);
- Add_Goto (Table.States (621), 167, 776);
- Add_Goto (Table.States (621), 168, 777);
- Add_Goto (Table.States (621), 191, 408);
- Add_Goto (Table.States (621), 197, 133);
- Add_Goto (Table.States (621), 221, 273);
- Add_Goto (Table.States (621), 239, 477);
- Add_Goto (Table.States (621), 258, 135);
- Add_Goto (Table.States (621), 272, 92);
- Add_Goto (Table.States (621), 273, 275);
- Add_Goto (Table.States (621), 275, 136);
- Add_Goto (Table.States (621), 277, 778);
- Add_Goto (Table.States (621), 278, 410);
- Add_Goto (Table.States (621), 282, 137);
- Add_Goto (Table.States (621), 283, 138);
- Add_Goto (Table.States (621), 284, 139);
- Add_Goto (Table.States (621), 285, 140);
- Add_Goto (Table.States (621), 286, 141);
- Add_Goto (Table.States (621), 287, 142);
- Add_Goto (Table.States (621), 293, 97);
- Add_Goto (Table.States (621), 301, 277);
- Add_Goto (Table.States (621), 314, 480);
- Add_Goto (Table.States (621), 320, 144);
+ Add_Action (Table.States (621), 96, 129);
+ Add_Action (Table.States (621), 104, 130);
+ Add_Action (Table.States (621), 105, 120);
+ Add_Action (Table.States (621), 106, 34);
+ Add_Action (Table.States (621), 107, 35);
+ Table.States (621).Goto_List.Set_Capacity (13);
+ Add_Goto (Table.States (621), 118, 131);
+ Add_Goto (Table.States (621), 129, 42);
+ Add_Goto (Table.States (621), 198, 134);
+ Add_Goto (Table.States (621), 235, 780);
+ Add_Goto (Table.States (621), 240, 275);
+ Add_Goto (Table.States (621), 259, 136);
+ Add_Goto (Table.States (621), 273, 93);
+ Add_Goto (Table.States (621), 278, 469);
+ Add_Goto (Table.States (621), 294, 98);
+ Add_Goto (Table.States (621), 302, 470);
Add_Goto (Table.States (621), 321, 145);
- Add_Goto (Table.States (621), 330, 146);
- Table.States (621).Kernel := To_Vector (((115, 76, 1, False),
(115, 76, 3, False), (224, 76, 4, False),
- (239, 76, 4, True)));
- Table.States (621).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 125, 0)));
+ Add_Goto (Table.States (621), 322, 146);
+ Add_Goto (Table.States (621), 331, 147);
+ Table.States (621).Kernel := To_Vector ((0 => (234, 80, 1, True)));
+ Table.States (621).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
Table.States (621).Minimal_Complete_Actions_Recursive := True;
- Table.States (622).Action_List.Set_Capacity (10);
- Add_Action (Table.States (622), (10, 21, 37, 42, 74, 77, 82, 83,
87, 96), (314, 2), 2,
- subtype_indication_2'Access, null);
- Table.States (622).Kernel := To_Vector ((0 => (314, 155, 0,
False)));
- Table.States (622).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 314, 2)));
- Table.States (623).Action_List.Set_Capacity (10);
- Add_Action (Table.States (623), (10, 21, 37, 42, 74, 77, 82, 83,
87, 96), (155, 1), 1, null, null);
- Table.States (623).Kernel := To_Vector ((0 => (155, 224, 0,
False)));
- Table.States (623).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 155, 1)));
- Table.States (624).Action_List.Set_Capacity (6);
- Add_Action (Table.States (624), 37, Reduce, (230, 3), 4, null,
null);
- Add_Action (Table.States (624), 76, 235);
- Add_Action (Table.States (624), 84, 237);
- Add_Action (Table.States (624), 87, Reduce, (230, 3), 4, null,
null);
- Add_Action (Table.States (624), 101, 239);
- Add_Action (Table.States (624), 102, 240);
- Table.States (624).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (624), 115, 241);
- Add_Goto (Table.States (624), 322, 242);
- Table.States (624).Kernel := To_Vector (((128, 239, 2, True),
(230, 239, 0, False), (239, 239, 5, True),
- (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (624).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 230, 4)));
- Table.States (625).Action_List.Set_Capacity (3);
- Add_Action (Table.States (625), 104, 119);
- Add_Action (Table.States (625), 105, 33);
- Add_Action (Table.States (625), 106, 34);
- Table.States (625).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (625), 128, 41);
- Add_Goto (Table.States (625), 239, 773);
- Add_Goto (Table.States (625), 272, 92);
- Add_Goto (Table.States (625), 293, 97);
- Table.States (625).Kernel := To_Vector (((314, 41, 5, False),
(314, 41, 1, False)));
- Table.States (625).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (626).Action_List.Set_Capacity (4);
- Add_Action (Table.States (626), 59, 779);
- Add_Action (Table.States (626), 104, 119);
- Add_Action (Table.States (626), 105, 33);
+ Table.States (622).Action_List.Set_Capacity (17);
+ Add_Action (Table.States (622), 10, Reduce, (288, 0), 4, null,
null);
+ Add_Action (Table.States (622), 20, Reduce, (288, 0), 4, null,
null);
+ Add_Action (Table.States (622), 21, Reduce, (288, 0), 4, null,
null);
+ Add_Action (Table.States (622), 22, Reduce, (288, 0), 4, null,
null);
+ Add_Action (Table.States (622), 23, Reduce, (288, 0), 4, null,
null);
+ Add_Action (Table.States (622), 35, Reduce, (288, 0), 4, null,
null);
+ Add_Action (Table.States (622), 37, Reduce, (288, 0), 4, null,
null);
+ Add_Action (Table.States (622), 43, Reduce, (288, 0), 4, null,
null);
+ Add_Action (Table.States (622), 53, Reduce, (288, 0), 4, null,
null);
+ Add_Action (Table.States (622), 68, Reduce, (288, 0), 4, null,
null);
+ Add_Action (Table.States (622), 74, Reduce, (288, 0), 4, null,
null);
+ Add_Action (Table.States (622), 75, Reduce, (288, 0), 4, null,
null);
+ Add_Action (Table.States (622), 77, Reduce, (288, 0), 4, null,
null);
+ Add_Action (Table.States (622), 80, 621);
+ Add_Conflict (Table.States (622), 80, (288, 0), 4, null, null);
+ Add_Action (Table.States (622), 84, Reduce, (288, 0), 4, null,
null);
+ Add_Action (Table.States (622), 88, Reduce, (288, 0), 4, null,
null);
+ Add_Action (Table.States (622), 97, Reduce, (288, 0), 4, null,
null);
+ Table.States (622).Kernel := To_Vector (((234, 234, 2, True),
(288, 234, 0, False)));
+ Table.States (622).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 288, 4)));
+ Table.States (623).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (623), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (191, 0), 5, exit_statement_0'Access, null);
+ Table.States (623).Kernel := To_Vector ((0 => (191, 97, 0,
False)));
+ Table.States (623).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 191, 5)));
+ Table.States (624).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (624), 38, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (624), 55, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (624), 78, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (624), 79, 31);
+ Add_Action (Table.States (624), 86, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (624), 95, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (624), 96, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (624), 98, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (624), 100, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (624), 105, 120);
+ Add_Action (Table.States (624), 106, 34);
+ Add_Action (Table.States (624), 107, 35);
+ Table.States (624).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (624), 129, 42);
+ Add_Goto (Table.States (624), 240, 781);
+ Add_Goto (Table.States (624), 273, 93);
+ Add_Goto (Table.States (624), 294, 98);
+ Table.States (624).Kernel := To_Vector (((259, 41, 0, False),
(315, 41, 5, False), (315, 41, 1, False)));
+ Table.States (624).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 259, 1)));
+ Table.States (625).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (625), (37, 88), (231, 2), 4,
iterator_specification_2'Access, null);
+ Table.States (625).Kernel := To_Vector ((0 => (231, 168, 0,
False)));
+ Table.States (625).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 231, 4)));
+ Table.States (626).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (626), 3, 122);
+ Add_Action (Table.States (626), 39, 123);
+ Add_Action (Table.States (626), 40, 124);
+ Add_Action (Table.States (626), 41, 125);
+ Add_Action (Table.States (626), 76, 127);
+ Add_Action (Table.States (626), 79, 31);
+ Add_Action (Table.States (626), 95, 128);
+ Add_Action (Table.States (626), 96, 129);
+ Add_Action (Table.States (626), 104, 130);
+ Add_Action (Table.States (626), 105, 120);
Add_Action (Table.States (626), 106, 34);
- Table.States (626).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (626), 128, 41);
- Add_Goto (Table.States (626), 239, 780);
- Add_Goto (Table.States (626), 272, 92);
- Add_Goto (Table.States (626), 293, 97);
- Table.States (626).Kernel := To_Vector (((230, 42, 2, False),
(230, 42, 1, False)));
- Table.States (626).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (627).Action_List.Set_Capacity (41);
- Add_Action (Table.States (627), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73,
74, 93, 104, 105, 106, 107), (121, 0), 5,
- aspect_clause_0'Access, null);
- Table.States (627).Kernel := To_Vector ((0 => (121, 96, 0,
False)));
- Table.States (627).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 121, 5)));
- Table.States (628).Action_List.Set_Capacity (1);
- Add_Action (Table.States (628), 96, 781);
- Table.States (628).Kernel := To_Vector ((0 => (127, 192, 1,
False)));
- Table.States (628).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 781)));
- Table.States (629).Action_List.Set_Capacity (1);
- Add_Action (Table.States (629), 38, 782);
- Table.States (629).Kernel := To_Vector ((0 => (235, 12, 2,
False)));
- Table.States (629).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 38, 782)));
- Table.States (630).Action_List.Set_Capacity (1);
- Add_Action (Table.States (630), 104, 783);
+ Add_Action (Table.States (626), 107, 35);
+ Table.States (626).Goto_List.Set_Capacity (12);
+ Add_Goto (Table.States (626), 118, 131);
+ Add_Goto (Table.States (626), 129, 42);
+ Add_Goto (Table.States (626), 198, 134);
+ Add_Goto (Table.States (626), 240, 275);
+ Add_Goto (Table.States (626), 259, 136);
+ Add_Goto (Table.States (626), 273, 93);
+ Add_Goto (Table.States (626), 278, 782);
+ Add_Goto (Table.States (626), 294, 98);
+ Add_Goto (Table.States (626), 302, 482);
+ Add_Goto (Table.States (626), 321, 145);
+ Add_Goto (Table.States (626), 322, 146);
+ Add_Goto (Table.States (626), 331, 147);
+ Table.States (626).Kernel := To_Vector ((0 => (156, 53, 3,
False)));
+ Table.States (626).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (627).Action_List.Set_Capacity (21);
+ Add_Action (Table.States (627), 3, 122);
+ Add_Action (Table.States (627), 15, 259);
+ Add_Action (Table.States (627), 28, 260);
+ Add_Action (Table.States (627), 32, 261);
+ Add_Action (Table.States (627), 39, 123);
+ Add_Action (Table.States (627), 40, 783);
+ Add_Action (Table.States (627), 41, 125);
+ Add_Action (Table.States (627), 44, 264);
+ Add_Action (Table.States (627), 52, 126);
+ Add_Action (Table.States (627), 76, 127);
+ Add_Action (Table.States (627), 77, Reduce, (125, 6), 0, null,
null);
+ Add_Action (Table.States (627), 79, 31);
+ Add_Action (Table.States (627), 80, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (627), 84, Reduce, (125, 6), 0, null,
null);
+ Add_Action (Table.States (627), 88, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (627), 95, 128);
+ Add_Action (Table.States (627), 96, 129);
+ Add_Action (Table.States (627), 104, 130);
+ Add_Action (Table.States (627), 105, 120);
+ Add_Action (Table.States (627), 106, 34);
+ Add_Action (Table.States (627), 107, 265);
+ Table.States (627).Goto_List.Set_Capacity (32);
+ Add_Goto (Table.States (627), 118, 131);
+ Add_Goto (Table.States (627), 125, 266);
+ Add_Goto (Table.States (627), 126, 407);
+ Add_Goto (Table.States (627), 129, 42);
+ Add_Goto (Table.States (627), 137, 268);
+ Add_Goto (Table.States (627), 154, 408);
+ Add_Goto (Table.States (627), 166, 270);
+ Add_Goto (Table.States (627), 167, 271);
+ Add_Goto (Table.States (627), 168, 784);
+ Add_Goto (Table.States (627), 169, 785);
+ Add_Goto (Table.States (627), 192, 409);
+ Add_Goto (Table.States (627), 198, 134);
+ Add_Goto (Table.States (627), 222, 274);
+ Add_Goto (Table.States (627), 240, 480);
+ Add_Goto (Table.States (627), 259, 136);
+ Add_Goto (Table.States (627), 273, 93);
+ Add_Goto (Table.States (627), 274, 276);
+ Add_Goto (Table.States (627), 276, 137);
+ Add_Goto (Table.States (627), 278, 786);
+ Add_Goto (Table.States (627), 279, 411);
+ Add_Goto (Table.States (627), 283, 138);
+ Add_Goto (Table.States (627), 284, 139);
+ Add_Goto (Table.States (627), 285, 140);
+ Add_Goto (Table.States (627), 286, 141);
+ Add_Goto (Table.States (627), 287, 142);
+ Add_Goto (Table.States (627), 288, 143);
+ Add_Goto (Table.States (627), 294, 98);
+ Add_Goto (Table.States (627), 302, 278);
+ Add_Goto (Table.States (627), 315, 483);
+ Add_Goto (Table.States (627), 321, 145);
+ Add_Goto (Table.States (627), 322, 146);
+ Add_Goto (Table.States (627), 331, 147);
+ Table.States (627).Kernel := To_Vector (((116, 76, 1, False),
(116, 76, 3, False), (225, 76, 4, False),
+ (240, 76, 4, True)));
+ Table.States (627).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 126, 0)));
+ Table.States (627).Minimal_Complete_Actions_Recursive := True;
+ Table.States (628).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (628), (10, 21, 37, 42, 74, 77, 83, 84,
88, 97), (315, 2), 2,
+ subtype_indication_2'Access, null);
+ Table.States (628).Kernel := To_Vector ((0 => (315, 156, 0,
False)));
+ Table.States (628).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 315, 2)));
+ Table.States (629).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (629), (10, 21, 37, 42, 74, 77, 83, 84,
88, 97), (156, 1), 1, null, null);
+ Table.States (629).Kernel := To_Vector ((0 => (156, 225, 0,
False)));
+ Table.States (629).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 156, 1)));
+ Table.States (630).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (630), 37, Reduce, (231, 3), 4, null,
null);
+ Add_Action (Table.States (630), 76, 236);
+ Add_Action (Table.States (630), 85, 238);
+ Add_Action (Table.States (630), 88, Reduce, (231, 3), 4, null,
null);
+ Add_Action (Table.States (630), 102, 240);
+ Add_Action (Table.States (630), 103, 241);
Table.States (630).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (630), 144, 784);
- Add_Goto (Table.States (630), 145, 785);
- Table.States (630).Kernel := To_Vector ((0 => (281, 235, 11,
False)));
- Table.States (630).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 783)));
- Table.States (631).Action_List.Set_Capacity (41);
- Add_Action (Table.States (631), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73,
74, 93, 104, 105, 106, 107), (182, 0), 5,
- enumeration_representation_clause_0'Access, null);
- Table.States (631).Kernel := To_Vector ((0 => (182, 96, 0,
False)));
- Table.States (631).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 182, 5)));
- Table.States (632).Action_List.Set_Capacity (11);
- Add_Action (Table.States (632), 21, Reduce, (240, 0), 1, null,
name_opt_0_check'Access);
- Add_Action (Table.States (632), 35, Reduce, (240, 0), 1, null,
name_opt_0_check'Access);
- Add_Action (Table.States (632), 56, Reduce, (240, 0), 1, null,
name_opt_0_check'Access);
- Add_Action (Table.States (632), 74, Reduce, (240, 0), 1, null,
name_opt_0_check'Access);
- Add_Action (Table.States (632), 76, 235);
- Add_Action (Table.States (632), 77, Reduce, (240, 0), 1, null,
name_opt_0_check'Access);
- Add_Action (Table.States (632), 82, Reduce, (240, 0), 1, null,
name_opt_0_check'Access);
- Add_Action (Table.States (632), 84, 237);
- Add_Action (Table.States (632), 96, Reduce, (240, 0), 1, null,
name_opt_0_check'Access);
- Add_Action (Table.States (632), 101, 239);
- Add_Action (Table.States (632), 102, 240);
- Table.States (632).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (632), 115, 241);
- Add_Goto (Table.States (632), 322, 242);
- Table.States (632).Kernel := To_Vector (((128, 239, 2, True),
(239, 239, 5, True), (239, 239, 2, True),
- (240, 239, 0, False), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (632).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 240, 1)));
- Table.States (633).Action_List.Set_Capacity (7);
- Add_Action (Table.States (633), (21, 35, 56, 74, 77, 82, 96),
(291, 0), 3, result_profile_0'Access, null);
- Table.States (633).Kernel := To_Vector ((0 => (291, 240, 0,
False)));
- Table.States (633).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 291, 3)));
- Table.States (634).Action_List.Set_Capacity (11);
- Add_Action (Table.States (634), 7, Reduce, (118, 1), 0, null,
null);
- Add_Action (Table.States (634), 8, 401);
- Add_Action (Table.States (634), 33, Reduce, (118, 1), 0, null,
null);
- Add_Action (Table.States (634), 40, Reduce, (118, 1), 0, null,
null);
- Add_Action (Table.States (634), 45, Reduce, (118, 1), 0, null,
null);
- Add_Action (Table.States (634), 77, Reduce, (118, 1), 0, null,
null);
- Add_Action (Table.States (634), 82, Reduce, (118, 1), 0, null,
null);
- Add_Action (Table.States (634), 96, Reduce, (118, 1), 0, null,
null);
- Add_Action (Table.States (634), 104, Reduce, (118, 1), 0, null,
null);
- Add_Action (Table.States (634), 105, Reduce, (118, 1), 0, null,
null);
- Add_Action (Table.States (634), 106, Reduce, (118, 1), 0, null,
null);
- Table.States (634).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (634), 118, 786);
- Table.States (634).Kernel := To_Vector (((254, 81, 2, False),
(254, 81, 1, False), (254, 81, 3, False),
- (254, 81, 2, False)));
- Table.States (634).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 118, 0)));
- Table.States (635).Action_List.Set_Capacity (9);
- Add_Action (Table.States (635), (21, 35, 56, 58, 72, 74, 77, 82,
96), (199, 0), 3, formal_part_0'Access,
- null);
- Table.States (635).Kernel := To_Vector ((0 => (199, 77, 0,
False)));
- Table.States (635).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 199, 3)));
- Table.States (636).Action_List.Set_Capacity (3);
- Add_Action (Table.States (636), 77, Reduce, (254, 4), 0, null,
null);
- Add_Action (Table.States (636), 96, Reduce, (254, 4), 0, null,
null);
- Add_Action (Table.States (636), 104, 164);
+ Add_Goto (Table.States (630), 116, 242);
+ Add_Goto (Table.States (630), 323, 243);
+ Table.States (630).Kernel := To_Vector (((129, 240, 2, True),
(231, 240, 0, False), (240, 240, 5, True),
+ (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (630).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 231, 4)));
+ Table.States (631).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (631), 79, 31);
+ Add_Action (Table.States (631), 105, 120);
+ Add_Action (Table.States (631), 106, 34);
+ Add_Action (Table.States (631), 107, 35);
+ Table.States (631).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (631), 129, 42);
+ Add_Goto (Table.States (631), 240, 781);
+ Add_Goto (Table.States (631), 273, 93);
+ Add_Goto (Table.States (631), 294, 98);
+ Table.States (631).Kernel := To_Vector (((315, 41, 5, False),
(315, 41, 1, False)));
+ Table.States (631).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (632).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (632), 59, 787);
+ Add_Action (Table.States (632), 79, 31);
+ Add_Action (Table.States (632), 105, 120);
+ Add_Action (Table.States (632), 106, 34);
+ Add_Action (Table.States (632), 107, 35);
+ Table.States (632).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (632), 129, 42);
+ Add_Goto (Table.States (632), 240, 788);
+ Add_Goto (Table.States (632), 273, 93);
+ Add_Goto (Table.States (632), 294, 98);
+ Table.States (632).Kernel := To_Vector (((231, 42, 2, False),
(231, 42, 1, False)));
+ Table.States (632).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (633).Action_List.Set_Capacity (42);
+ Add_Action (Table.States (633), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73,
74, 79, 94, 105, 106, 107, 108), (122, 0),
+ 5, aspect_clause_0'Access, null);
+ Table.States (633).Kernel := To_Vector ((0 => (122, 97, 0,
False)));
+ Table.States (633).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 5)));
+ Table.States (634).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (634), 97, 789);
+ Table.States (634).Kernel := To_Vector ((0 => (128, 193, 1,
False)));
+ Table.States (634).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 789)));
+ Table.States (635).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (635), 38, 790);
+ Table.States (635).Kernel := To_Vector ((0 => (236, 12, 2,
False)));
+ Table.States (635).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 38, 790)));
+ Table.States (636).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (636), 105, 791);
Table.States (636).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (636), 219, 493);
- Add_Goto (Table.States (636), 254, 787);
- Table.States (636).Kernel := To_Vector ((0 => (255, 96, 0, True)));
- Table.States (636).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 254, 0)));
- Table.States (636).Minimal_Complete_Actions_Recursive := True;
- Table.States (637).Action_List.Set_Capacity (6);
- Add_Action (Table.States (637), 74, 337);
- Add_Action (Table.States (637), 76, 235);
- Add_Action (Table.States (637), 84, 237);
- Add_Action (Table.States (637), 96, Reduce, (122, 1), 0, null,
null);
- Add_Action (Table.States (637), 101, 239);
- Add_Action (Table.States (637), 102, 240);
- Table.States (637).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (637), 115, 241);
- Add_Goto (Table.States (637), 122, 788);
- Add_Goto (Table.States (637), 322, 242);
- Table.States (637).Kernel := To_Vector (((128, 239, 2, True),
(215, 239, 1, False), (239, 239, 5, True),
- (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (637).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (638).Action_List.Set_Capacity (6);
- Add_Action (Table.States (638), 74, 337);
- Add_Action (Table.States (638), 76, 235);
- Add_Action (Table.States (638), 84, 237);
- Add_Action (Table.States (638), 96, Reduce, (122, 1), 0, null,
null);
- Add_Action (Table.States (638), 101, 239);
+ Add_Goto (Table.States (636), 145, 792);
+ Add_Goto (Table.States (636), 146, 793);
+ Table.States (636).Kernel := To_Vector ((0 => (282, 236, 11,
False)));
+ Table.States (636).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 791)));
+ Table.States (637).Action_List.Set_Capacity (42);
+ Add_Action (Table.States (637), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73,
74, 79, 94, 105, 106, 107, 108), (183, 0),
+ 5, enumeration_representation_clause_0'Access, null);
+ Table.States (637).Kernel := To_Vector ((0 => (183, 97, 0,
False)));
+ Table.States (637).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 183, 5)));
+ Table.States (638).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (638), 21, Reduce, (241, 0), 1, null,
name_opt_0_check'Access);
+ Add_Action (Table.States (638), 35, Reduce, (241, 0), 1, null,
name_opt_0_check'Access);
+ Add_Action (Table.States (638), 56, Reduce, (241, 0), 1, null,
name_opt_0_check'Access);
+ Add_Action (Table.States (638), 74, Reduce, (241, 0), 1, null,
name_opt_0_check'Access);
+ Add_Action (Table.States (638), 76, 236);
+ Add_Action (Table.States (638), 77, Reduce, (241, 0), 1, null,
name_opt_0_check'Access);
+ Add_Action (Table.States (638), 83, Reduce, (241, 0), 1, null,
name_opt_0_check'Access);
+ Add_Action (Table.States (638), 85, 238);
+ Add_Action (Table.States (638), 97, Reduce, (241, 0), 1, null,
name_opt_0_check'Access);
Add_Action (Table.States (638), 102, 240);
- Table.States (638).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (638), 115, 241);
- Add_Goto (Table.States (638), 122, 789);
- Add_Goto (Table.States (638), 322, 242);
- Table.States (638).Kernel := To_Vector (((128, 239, 2, True),
(215, 239, 1, False), (239, 239, 5, True),
- (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (638).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (639).Action_List.Set_Capacity (6);
- Add_Action (Table.States (639), 74, 337);
- Add_Action (Table.States (639), 76, 235);
- Add_Action (Table.States (639), 84, 237);
- Add_Action (Table.States (639), 96, Reduce, (122, 1), 0, null,
null);
- Add_Action (Table.States (639), 101, 239);
- Add_Action (Table.States (639), 102, 240);
- Table.States (639).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (639), 115, 241);
- Add_Goto (Table.States (639), 122, 790);
- Add_Goto (Table.States (639), 322, 242);
- Table.States (639).Kernel := To_Vector (((128, 239, 2, True),
(215, 239, 1, False), (239, 239, 5, True),
- (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (639).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (640).Action_List.Set_Capacity (17);
- Add_Action (Table.States (640), 6, 791);
- Add_Action (Table.States (640), 7, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (640), 11, 701);
- Add_Action (Table.States (640), 19, 792);
- Add_Action (Table.States (640), 20, 793);
- Add_Action (Table.States (640), 34, 704);
- Add_Action (Table.States (640), 36, 794);
- Add_Action (Table.States (640), 38, 795);
- Add_Action (Table.States (640), 39, Reduce, (109, 5), 0, null,
null);
- Add_Action (Table.States (640), 40, 386);
- Add_Action (Table.States (640), 49, Reduce, (111, 5), 0, null,
null);
- Add_Action (Table.States (640), 51, 708);
- Add_Action (Table.States (640), 53, 796);
- Add_Action (Table.States (640), 64, 711);
- Add_Action (Table.States (640), 65, 797);
- Add_Action (Table.States (640), 66, 713);
- Add_Action (Table.States (640), 76, 798);
- Table.States (640).Goto_List.Set_Capacity (8);
- Add_Goto (Table.States (640), 109, 799);
- Add_Goto (Table.States (640), 111, 800);
- Add_Goto (Table.States (640), 114, 801);
- Add_Goto (Table.States (640), 120, 802);
- Add_Goto (Table.States (640), 202, 803);
- Add_Goto (Table.States (640), 203, 804);
- Add_Goto (Table.States (640), 228, 805);
- Add_Goto (Table.States (640), 241, 723);
- Table.States (640).Kernel := To_Vector (((201, 35, 2, False),
(201, 35, 2, False)));
- Table.States (640).Minimal_Complete_Actions := To_Vector
(((Reduce, 111, 0), (Shift, 65, 797)));
- Table.States (641).Action_List.Set_Capacity (1);
- Add_Action (Table.States (641), 96, 806);
- Table.States (641).Kernel := To_Vector ((0 => (201, 122, 1,
False)));
- Table.States (641).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 806)));
- Table.States (642).Action_List.Set_Capacity (1);
- Add_Action (Table.States (642), 39, 807);
- Table.States (642).Kernel := To_Vector ((0 => (204, 35, 3,
False)));
- Table.States (642).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 39, 807)));
- Table.States (643).Action_List.Set_Capacity (7);
- Add_Action (Table.States (643), 41, 644);
- Add_Action (Table.States (643), 74, 337);
- Add_Action (Table.States (643), 80, 645);
- Add_Action (Table.States (643), 96, Reduce, (122, 1), 0, null,
null);
- Add_Action (Table.States (643), 104, 119);
- Add_Action (Table.States (643), 105, 33);
- Add_Action (Table.States (643), 106, 34);
- Table.States (643).Goto_List.Set_Capacity (6);
- Add_Goto (Table.States (643), 122, 808);
- Add_Goto (Table.States (643), 128, 41);
- Add_Goto (Table.States (643), 239, 646);
- Add_Goto (Table.States (643), 272, 92);
- Add_Goto (Table.States (643), 293, 97);
- Add_Goto (Table.States (643), 310, 809);
- Table.States (643).Kernel := To_Vector (((200, 6, 2, False), (200,
6, 1, False)));
- Table.States (643).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (644).Action_List.Set_Capacity (2);
- Add_Action (Table.States (644), (74, 96), (310, 2), 1, null, null);
- Table.States (644).Kernel := To_Vector ((0 => (310, 41, 0,
False)));
- Table.States (644).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 310, 1)));
- Table.States (645).Action_List.Set_Capacity (2);
- Add_Action (Table.States (645), (74, 96), (310, 1), 1, null, null);
- Table.States (645).Kernel := To_Vector ((0 => (310, 80, 0,
False)));
- Table.States (645).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 310, 1)));
- Table.States (646).Action_List.Set_Capacity (6);
- Add_Action (Table.States (646), 74, Reduce, (310, 0), 1,
subprogram_default_0'Access, null);
- Add_Action (Table.States (646), 76, 235);
- Add_Action (Table.States (646), 84, 237);
- Add_Action (Table.States (646), 96, Reduce, (310, 0), 1,
subprogram_default_0'Access, null);
- Add_Action (Table.States (646), 101, 239);
- Add_Action (Table.States (646), 102, 240);
- Table.States (646).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (646), 115, 241);
- Add_Goto (Table.States (646), 322, 242);
- Table.States (646).Kernel := To_Vector (((128, 239, 2, True),
(239, 239, 5, True), (239, 239, 2, True),
- (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (310, 239, 0, False)));
- Table.States (646).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 310, 1)));
- Table.States (647).Action_List.Set_Capacity (2);
- Add_Action (Table.States (647), 74, 337);
- Add_Action (Table.States (647), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (647).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (647), 122, 810);
- Table.States (647).Kernel := To_Vector ((0 => (200, 310, 1,
False)));
- Table.States (647).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (648).Action_List.Set_Capacity (8);
- Add_Action (Table.States (648), (29, 47, 48, 50, 69, 71, 74, 104),
(200, 3), 4,
- formal_subprogram_declaration_3'Access, null);
- Table.States (648).Kernel := To_Vector ((0 => (200, 96, 0,
False)));
- Table.States (648).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 200, 4)));
+ Add_Action (Table.States (638), 103, 241);
+ Table.States (638).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (638), 116, 242);
+ Add_Goto (Table.States (638), 323, 243);
+ Table.States (638).Kernel := To_Vector (((129, 240, 2, True),
(240, 240, 5, True), (240, 240, 2, True),
+ (241, 240, 0, False), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (638).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 241, 1)));
+ Table.States (639).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (639), (21, 35, 56, 74, 77, 83, 97),
(292, 0), 3, result_profile_0'Access, null);
+ Table.States (639).Kernel := To_Vector ((0 => (292, 241, 0,
False)));
+ Table.States (639).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 292, 3)));
+ Table.States (640).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (640), 7, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (640), 8, 402);
+ Add_Action (Table.States (640), 33, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (640), 40, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (640), 45, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (640), 77, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (640), 79, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (640), 83, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (640), 97, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (640), 105, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (640), 106, Reduce, (119, 1), 0, null,
null);
+ Add_Action (Table.States (640), 107, Reduce, (119, 1), 0, null,
null);
+ Table.States (640).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (640), 119, 794);
+ Table.States (640).Kernel := To_Vector (((255, 82, 2, False),
(255, 82, 1, False), (255, 82, 3, False),
+ (255, 82, 2, False)));
+ Table.States (640).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 119, 0)));
+ end Subr_12;
+ procedure Subr_13
+ is begin
+ Table.States (641).Action_List.Set_Capacity (9);
+ Add_Action (Table.States (641), (21, 35, 56, 58, 72, 74, 77, 83,
97), (200, 0), 3, formal_part_0'Access,
+ null);
+ Table.States (641).Kernel := To_Vector ((0 => (200, 77, 0,
False)));
+ Table.States (641).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 200, 3)));
+ Table.States (642).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (642), 77, Reduce, (255, 4), 0, null,
null);
+ Add_Action (Table.States (642), 97, Reduce, (255, 4), 0, null,
null);
+ Add_Action (Table.States (642), 105, 165);
+ Table.States (642).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (642), 220, 496);
+ Add_Goto (Table.States (642), 255, 795);
+ Table.States (642).Kernel := To_Vector ((0 => (256, 97, 0, True)));
+ Table.States (642).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 255, 0)));
+ Table.States (642).Minimal_Complete_Actions_Recursive := True;
+ Table.States (643).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (643), 74, 338);
+ Add_Action (Table.States (643), 76, 236);
+ Add_Action (Table.States (643), 85, 238);
+ Add_Action (Table.States (643), 97, Reduce, (123, 1), 0, null,
null);
+ Add_Action (Table.States (643), 102, 240);
+ Add_Action (Table.States (643), 103, 241);
+ Table.States (643).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (643), 116, 242);
+ Add_Goto (Table.States (643), 123, 796);
+ Add_Goto (Table.States (643), 323, 243);
+ Table.States (643).Kernel := To_Vector (((129, 240, 2, True),
(216, 240, 1, False), (240, 240, 5, True),
+ (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (643).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (644).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (644), 74, 338);
+ Add_Action (Table.States (644), 76, 236);
+ Add_Action (Table.States (644), 85, 238);
+ Add_Action (Table.States (644), 97, Reduce, (123, 1), 0, null,
null);
+ Add_Action (Table.States (644), 102, 240);
+ Add_Action (Table.States (644), 103, 241);
+ Table.States (644).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (644), 116, 242);
+ Add_Goto (Table.States (644), 123, 797);
+ Add_Goto (Table.States (644), 323, 243);
+ Table.States (644).Kernel := To_Vector (((129, 240, 2, True),
(216, 240, 1, False), (240, 240, 5, True),
+ (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (644).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (645).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (645), 74, 338);
+ Add_Action (Table.States (645), 76, 236);
+ Add_Action (Table.States (645), 85, 238);
+ Add_Action (Table.States (645), 97, Reduce, (123, 1), 0, null,
null);
+ Add_Action (Table.States (645), 102, 240);
+ Add_Action (Table.States (645), 103, 241);
+ Table.States (645).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (645), 116, 242);
+ Add_Goto (Table.States (645), 123, 798);
+ Add_Goto (Table.States (645), 323, 243);
+ Table.States (645).Kernel := To_Vector (((129, 240, 2, True),
(216, 240, 1, False), (240, 240, 5, True),
+ (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (645).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (646).Action_List.Set_Capacity (17);
+ Add_Action (Table.States (646), 6, 799);
+ Add_Action (Table.States (646), 7, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (646), 11, 707);
+ Add_Action (Table.States (646), 19, 800);
+ Add_Action (Table.States (646), 20, 801);
+ Add_Action (Table.States (646), 34, 710);
+ Add_Action (Table.States (646), 36, 802);
+ Add_Action (Table.States (646), 38, 803);
+ Add_Action (Table.States (646), 39, Reduce, (110, 5), 0, null,
null);
+ Add_Action (Table.States (646), 40, 387);
+ Add_Action (Table.States (646), 49, Reduce, (112, 5), 0, null,
null);
+ Add_Action (Table.States (646), 51, 714);
+ Add_Action (Table.States (646), 53, 804);
+ Add_Action (Table.States (646), 64, 717);
+ Add_Action (Table.States (646), 65, 805);
+ Add_Action (Table.States (646), 66, 719);
+ Add_Action (Table.States (646), 76, 806);
+ Table.States (646).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (646), 110, 807);
+ Add_Goto (Table.States (646), 112, 808);
+ Add_Goto (Table.States (646), 115, 809);
+ Add_Goto (Table.States (646), 121, 810);
+ Add_Goto (Table.States (646), 203, 811);
+ Add_Goto (Table.States (646), 204, 812);
+ Add_Goto (Table.States (646), 229, 813);
+ Add_Goto (Table.States (646), 242, 729);
+ Table.States (646).Kernel := To_Vector (((202, 35, 2, False),
(202, 35, 2, False)));
+ Table.States (646).Minimal_Complete_Actions := To_Vector
(((Reduce, 112, 0), (Shift, 65, 805)));
+ Table.States (647).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (647), 97, 814);
+ Table.States (647).Kernel := To_Vector ((0 => (202, 123, 1,
False)));
+ Table.States (647).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 814)));
+ Table.States (648).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (648), 39, 815);
+ Table.States (648).Kernel := To_Vector ((0 => (205, 35, 3,
False)));
+ Table.States (648).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 39, 815)));
Table.States (649).Action_List.Set_Capacity (8);
- Add_Action (Table.States (649), (7, 40, 74, 82, 96, 104, 105,
106), (236, 1), 2, null, null);
- Table.States (649).Kernel := To_Vector ((0 => (236, 45, 0,
False)));
- Table.States (649).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 236, 2)));
- Table.States (650).Action_List.Set_Capacity (3);
- Add_Action (Table.States (650), 74, 337);
- Add_Action (Table.States (650), 82, 811);
- Add_Action (Table.States (650), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (650).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (650), 122, 812);
- Table.States (650).Kernel := To_Vector (((198, 114, 2, False),
(198, 114, 1, False)));
- Table.States (650).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (651).Action_List.Set_Capacity (4);
- Add_Action (Table.States (651), 7, 556);
- Add_Action (Table.States (651), 104, 119);
- Add_Action (Table.States (651), 105, 33);
- Add_Action (Table.States (651), 106, 34);
- Table.States (651).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (651), 128, 41);
- Add_Goto (Table.States (651), 239, 813);
- Add_Goto (Table.States (651), 272, 92);
- Add_Goto (Table.States (651), 293, 97);
- Table.States (651).Kernel := To_Vector (((114, 241, 2, False),
(114, 241, 3, True), (114, 241, 2, False),
- (198, 241, 3, False), (198, 241, 2, False)));
- Table.States (651).Minimal_Complete_Actions := To_Vector (((Shift,
7, 556), (Shift, 104, 119)));
- Table.States (652).Action_List.Set_Capacity (23);
- Add_Action (Table.States (652), 4, 1);
- Add_Action (Table.States (652), 5, 2);
- Add_Action (Table.States (652), 13, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (652), 15, 3);
- Add_Action (Table.States (652), 17, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (652), 18, 4);
- Add_Action (Table.States (652), 24, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (652), 27, 5);
- Add_Action (Table.States (652), 28, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (652), 31, 9);
- Add_Action (Table.States (652), 32, 10);
- Add_Action (Table.States (652), 37, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (652), 41, 13);
- Add_Action (Table.States (652), 48, 16);
- Add_Action (Table.States (652), 52, 20);
- Add_Action (Table.States (652), 57, 21);
- Add_Action (Table.States (652), 58, 22);
- Add_Action (Table.States (652), 61, 24);
- Add_Action (Table.States (652), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (652), 93, 31);
- Add_Action (Table.States (652), 104, 360);
- Add_Action (Table.States (652), 105, 33);
- Add_Action (Table.States (652), 106, 34);
- Table.States (652).Goto_List.Set_Capacity (31);
- Add_Goto (Table.States (652), 113, 36);
- Add_Goto (Table.States (652), 123, 38);
- Add_Goto (Table.States (652), 126, 39);
- Add_Goto (Table.States (652), 128, 41);
- Add_Goto (Table.States (652), 131, 42);
- Add_Goto (Table.States (652), 132, 43);
- Add_Goto (Table.States (652), 133, 44);
- Add_Goto (Table.States (652), 139, 47);
- Add_Goto (Table.States (652), 151, 50);
- Add_Goto (Table.States (652), 152, 51);
- Add_Goto (Table.States (652), 161, 53);
- Add_Goto (Table.States (652), 190, 57);
- Add_Goto (Table.States (652), 196, 59);
- Add_Goto (Table.States (652), 217, 68);
- Add_Goto (Table.States (652), 222, 70);
- Add_Goto (Table.States (652), 232, 72);
- Add_Goto (Table.States (652), 239, 73);
- Add_Goto (Table.States (652), 257, 83);
- Add_Goto (Table.States (652), 261, 86);
- Add_Goto (Table.States (652), 272, 92);
- Add_Goto (Table.States (652), 276, 93);
- Add_Goto (Table.States (652), 290, 96);
- Add_Goto (Table.States (652), 293, 97);
- Add_Goto (Table.States (652), 294, 98);
- Add_Goto (Table.States (652), 298, 99);
- Add_Goto (Table.States (652), 299, 361);
- Add_Goto (Table.States (652), 300, 814);
- Add_Goto (Table.States (652), 302, 100);
- Add_Goto (Table.States (652), 303, 101);
- Add_Goto (Table.States (652), 306, 363);
- Add_Goto (Table.States (652), 323, 114);
- Table.States (652).Kernel := To_Vector ((0 => (222, 22, 3,
False)));
- Table.States (652).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 300, 0)));
- Table.States (653).Action_List.Set_Capacity (13);
- Add_Action (Table.States (653), 3, 121);
- Add_Action (Table.States (653), 39, 122);
- Add_Action (Table.States (653), 40, 123);
- Add_Action (Table.States (653), 41, 124);
- Add_Action (Table.States (653), 52, 125);
- Add_Action (Table.States (653), 68, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (653), 76, 126);
- Add_Action (Table.States (653), 94, 127);
- Add_Action (Table.States (653), 95, 128);
- Add_Action (Table.States (653), 103, 129);
- Add_Action (Table.States (653), 104, 119);
- Add_Action (Table.States (653), 105, 33);
- Add_Action (Table.States (653), 106, 34);
- Table.States (653).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (653), 117, 130);
- Add_Goto (Table.States (653), 128, 41);
- Add_Goto (Table.States (653), 191, 131);
- Add_Goto (Table.States (653), 192, 815);
- Add_Goto (Table.States (653), 197, 133);
- Add_Goto (Table.States (653), 239, 134);
- Add_Goto (Table.States (653), 258, 135);
- Add_Goto (Table.States (653), 272, 92);
- Add_Goto (Table.States (653), 275, 136);
- Add_Goto (Table.States (653), 282, 137);
- Add_Goto (Table.States (653), 283, 138);
- Add_Goto (Table.States (653), 284, 139);
- Add_Goto (Table.States (653), 285, 140);
- Add_Goto (Table.States (653), 286, 141);
- Add_Goto (Table.States (653), 287, 142);
- Add_Goto (Table.States (653), 293, 97);
- Add_Goto (Table.States (653), 301, 143);
- Add_Goto (Table.States (653), 320, 144);
- Add_Goto (Table.States (653), 321, 145);
- Add_Goto (Table.States (653), 330, 146);
- Table.States (653).Kernel := To_Vector ((0 => (174, 23, 1,
False)));
- Table.States (653).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (654).Action_List.Set_Capacity (1);
- Add_Action (Table.States (654), 32, 816);
- Table.States (654).Kernel := To_Vector ((0 => (222, 24, 2,
False)));
- Table.States (654).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 32, 816)));
- Table.States (655).Action_List.Set_Capacity (3);
- Add_Action (Table.States (655), (22, 23, 24), (175, 1), 1, null,
null);
- Table.States (655).Kernel := To_Vector ((0 => (175, 174, 0,
False)));
- Table.States (655).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 175, 1)));
+ Add_Action (Table.States (649), 41, 650);
+ Add_Action (Table.States (649), 74, 338);
+ Add_Action (Table.States (649), 79, 31);
+ Add_Action (Table.States (649), 81, 651);
+ Add_Action (Table.States (649), 97, Reduce, (123, 1), 0, null,
null);
+ Add_Action (Table.States (649), 105, 120);
+ Add_Action (Table.States (649), 106, 34);
+ Add_Action (Table.States (649), 107, 35);
+ Table.States (649).Goto_List.Set_Capacity (6);
+ Add_Goto (Table.States (649), 123, 816);
+ Add_Goto (Table.States (649), 129, 42);
+ Add_Goto (Table.States (649), 240, 652);
+ Add_Goto (Table.States (649), 273, 93);
+ Add_Goto (Table.States (649), 294, 98);
+ Add_Goto (Table.States (649), 311, 817);
+ Table.States (649).Kernel := To_Vector (((201, 6, 2, False), (201,
6, 1, False)));
+ Table.States (649).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (650).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (650), (74, 97), (311, 2), 1, null, null);
+ Table.States (650).Kernel := To_Vector ((0 => (311, 41, 0,
False)));
+ Table.States (650).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 311, 1)));
+ Table.States (651).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (651), (74, 97), (311, 1), 1, null, null);
+ Table.States (651).Kernel := To_Vector ((0 => (311, 81, 0,
False)));
+ Table.States (651).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 311, 1)));
+ Table.States (652).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (652), 74, Reduce, (311, 0), 1,
subprogram_default_0'Access, null);
+ Add_Action (Table.States (652), 76, 236);
+ Add_Action (Table.States (652), 85, 238);
+ Add_Action (Table.States (652), 97, Reduce, (311, 0), 1,
subprogram_default_0'Access, null);
+ Add_Action (Table.States (652), 102, 240);
+ Add_Action (Table.States (652), 103, 241);
+ Table.States (652).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (652), 116, 242);
+ Add_Goto (Table.States (652), 323, 243);
+ Table.States (652).Kernel := To_Vector (((129, 240, 2, True),
(240, 240, 5, True), (240, 240, 2, True),
+ (273, 240, 3, True), (294, 240, 2, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (311, 240, 0, False)));
+ Table.States (652).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 311, 1)));
+ Table.States (653).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (653), 74, 338);
+ Add_Action (Table.States (653), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (653).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (653), 123, 818);
+ Table.States (653).Kernel := To_Vector ((0 => (201, 311, 1,
False)));
+ Table.States (653).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (654).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (654), (29, 47, 48, 50, 69, 71, 74, 105),
(201, 3), 4,
+ formal_subprogram_declaration_3'Access, null);
+ Table.States (654).Kernel := To_Vector ((0 => (201, 97, 0,
False)));
+ Table.States (654).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 201, 4)));
+ Table.States (655).Action_List.Set_Capacity (9);
+ Add_Action (Table.States (655), (7, 40, 74, 79, 83, 97, 105, 106,
107), (237, 1), 2, null, null);
+ Table.States (655).Kernel := To_Vector ((0 => (237, 45, 0,
False)));
+ Table.States (655).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 237, 2)));
Table.States (656).Action_List.Set_Capacity (3);
- Add_Action (Table.States (656), 22, 817);
- Add_Action (Table.States (656), 23, 653);
- Add_Action (Table.States (656), 24, 818);
+ Add_Action (Table.States (656), 74, 338);
+ Add_Action (Table.States (656), 83, 819);
+ Add_Action (Table.States (656), 97, Reduce, (123, 1), 0, null,
null);
Table.States (656).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (656), 174, 819);
- Table.States (656).Kernel := To_Vector (((175, 175, 2, True),
(222, 175, 4, False), (222, 175, 3, False)));
- Table.States (656).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 818)));
- Table.States (657).Action_List.Set_Capacity (39);
- Add_Action (Table.States (657), (4, 5, 13, 15, 17, 18, 25, 27, 28,
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
- 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93,
104, 105, 106, 107), (332, 0), 5,
+ Add_Goto (Table.States (656), 123, 820);
+ Table.States (656).Kernel := To_Vector (((199, 115, 2, False),
(199, 115, 1, False)));
+ Table.States (656).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (657).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (657), 7, 560);
+ Add_Action (Table.States (657), 79, 31);
+ Add_Action (Table.States (657), 105, 120);
+ Add_Action (Table.States (657), 106, 34);
+ Add_Action (Table.States (657), 107, 35);
+ Table.States (657).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (657), 129, 42);
+ Add_Goto (Table.States (657), 240, 821);
+ Add_Goto (Table.States (657), 273, 93);
+ Add_Goto (Table.States (657), 294, 98);
+ Table.States (657).Kernel := To_Vector (((115, 242, 2, False),
(115, 242, 3, True), (115, 242, 2, False),
+ (199, 242, 3, False), (199, 242, 2, False)));
+ Table.States (657).Minimal_Complete_Actions := To_Vector (((Shift,
7, 560), (Shift, 105, 120)));
+ Table.States (658).Action_List.Set_Capacity (24);
+ Add_Action (Table.States (658), 4, 1);
+ Add_Action (Table.States (658), 5, 2);
+ Add_Action (Table.States (658), 13, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (658), 15, 3);
+ Add_Action (Table.States (658), 17, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (658), 18, 4);
+ Add_Action (Table.States (658), 24, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (658), 27, 5);
+ Add_Action (Table.States (658), 28, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (658), 31, 9);
+ Add_Action (Table.States (658), 32, 10);
+ Add_Action (Table.States (658), 37, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (658), 41, 13);
+ Add_Action (Table.States (658), 48, 16);
+ Add_Action (Table.States (658), 52, 20);
+ Add_Action (Table.States (658), 57, 21);
+ Add_Action (Table.States (658), 58, 22);
+ Add_Action (Table.States (658), 61, 24);
+ Add_Action (Table.States (658), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (658), 79, 31);
+ Add_Action (Table.States (658), 94, 32);
+ Add_Action (Table.States (658), 105, 361);
+ Add_Action (Table.States (658), 106, 34);
+ Add_Action (Table.States (658), 107, 35);
+ Table.States (658).Goto_List.Set_Capacity (31);
+ Add_Goto (Table.States (658), 114, 37);
+ Add_Goto (Table.States (658), 124, 39);
+ Add_Goto (Table.States (658), 127, 40);
+ Add_Goto (Table.States (658), 129, 42);
+ Add_Goto (Table.States (658), 132, 43);
+ Add_Goto (Table.States (658), 133, 44);
+ Add_Goto (Table.States (658), 134, 45);
+ Add_Goto (Table.States (658), 140, 48);
+ Add_Goto (Table.States (658), 152, 51);
+ Add_Goto (Table.States (658), 153, 52);
+ Add_Goto (Table.States (658), 162, 54);
+ Add_Goto (Table.States (658), 191, 58);
+ Add_Goto (Table.States (658), 197, 60);
+ Add_Goto (Table.States (658), 218, 69);
+ Add_Goto (Table.States (658), 223, 71);
+ Add_Goto (Table.States (658), 233, 73);
+ Add_Goto (Table.States (658), 240, 74);
+ Add_Goto (Table.States (658), 258, 84);
+ Add_Goto (Table.States (658), 262, 87);
+ Add_Goto (Table.States (658), 273, 93);
+ Add_Goto (Table.States (658), 277, 94);
+ Add_Goto (Table.States (658), 291, 97);
+ Add_Goto (Table.States (658), 294, 98);
+ Add_Goto (Table.States (658), 295, 99);
+ Add_Goto (Table.States (658), 299, 100);
+ Add_Goto (Table.States (658), 300, 362);
+ Add_Goto (Table.States (658), 301, 822);
+ Add_Goto (Table.States (658), 303, 101);
+ Add_Goto (Table.States (658), 304, 102);
+ Add_Goto (Table.States (658), 307, 364);
+ Add_Goto (Table.States (658), 324, 115);
+ Table.States (658).Kernel := To_Vector ((0 => (223, 22, 3,
False)));
+ Table.States (658).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 301, 0)));
+ Table.States (659).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (659), 3, 122);
+ Add_Action (Table.States (659), 39, 123);
+ Add_Action (Table.States (659), 40, 124);
+ Add_Action (Table.States (659), 41, 125);
+ Add_Action (Table.States (659), 52, 126);
+ Add_Action (Table.States (659), 68, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (659), 76, 127);
+ Add_Action (Table.States (659), 79, 31);
+ Add_Action (Table.States (659), 95, 128);
+ Add_Action (Table.States (659), 96, 129);
+ Add_Action (Table.States (659), 104, 130);
+ Add_Action (Table.States (659), 105, 120);
+ Add_Action (Table.States (659), 106, 34);
+ Add_Action (Table.States (659), 107, 35);
+ Table.States (659).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (659), 118, 131);
+ Add_Goto (Table.States (659), 129, 42);
+ Add_Goto (Table.States (659), 192, 132);
+ Add_Goto (Table.States (659), 193, 823);
+ Add_Goto (Table.States (659), 198, 134);
+ Add_Goto (Table.States (659), 240, 135);
+ Add_Goto (Table.States (659), 259, 136);
+ Add_Goto (Table.States (659), 273, 93);
+ Add_Goto (Table.States (659), 276, 137);
+ Add_Goto (Table.States (659), 283, 138);
+ Add_Goto (Table.States (659), 284, 139);
+ Add_Goto (Table.States (659), 285, 140);
+ Add_Goto (Table.States (659), 286, 141);
+ Add_Goto (Table.States (659), 287, 142);
+ Add_Goto (Table.States (659), 288, 143);
+ Add_Goto (Table.States (659), 294, 98);
+ Add_Goto (Table.States (659), 302, 144);
+ Add_Goto (Table.States (659), 321, 145);
+ Add_Goto (Table.States (659), 322, 146);
+ Add_Goto (Table.States (659), 331, 147);
+ Table.States (659).Kernel := To_Vector ((0 => (175, 23, 1,
False)));
+ Table.States (659).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (660).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (660), 32, 824);
+ Table.States (660).Kernel := To_Vector ((0 => (223, 24, 2,
False)));
+ Table.States (660).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 32, 824)));
+ Table.States (661).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (661), (22, 23, 24), (176, 1), 1, null,
null);
+ Table.States (661).Kernel := To_Vector ((0 => (176, 175, 0,
False)));
+ Table.States (661).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 176, 1)));
+ Table.States (662).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (662), 22, 825);
+ Add_Action (Table.States (662), 23, 659);
+ Add_Action (Table.States (662), 24, 826);
+ Table.States (662).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (662), 175, 827);
+ Table.States (662).Kernel := To_Vector (((176, 176, 2, True),
(223, 176, 4, False), (223, 176, 3, False)));
+ Table.States (662).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 826)));
+ Table.States (663).Action_List.Set_Capacity (40);
+ Add_Action (Table.States (663), (4, 5, 13, 15, 17, 18, 25, 27, 28,
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
+ 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 79,
94, 105, 106, 107, 108), (333, 0), 5,
with_clause_0'Access, null);
- Table.States (657).Kernel := To_Vector ((0 => (332, 96, 0,
False)));
- Table.States (657).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 332, 5)));
- Table.States (658).Action_List.Set_Capacity (2);
- Add_Action (Table.States (658), 74, 337);
- Add_Action (Table.States (658), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (658).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (658), 122, 820);
- Table.States (658).Kernel := To_Vector ((0 => (248, 60, 1,
False)));
- Table.States (658).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (659).Action_List.Set_Capacity (17);
- Add_Action (Table.States (659), 13, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (659), 24, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (659), 25, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (659), 28, 183);
- Add_Action (Table.States (659), 29, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (659), 30, 8);
- Add_Action (Table.States (659), 40, 12);
- Add_Action (Table.States (659), 46, 14);
- Add_Action (Table.States (659), 47, 15);
- Add_Action (Table.States (659), 48, 16);
- Add_Action (Table.States (659), 50, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (659), 51, 19);
- Add_Action (Table.States (659), 63, 25);
- Add_Action (Table.States (659), 66, 26);
- Add_Action (Table.States (659), 69, 27);
- Add_Action (Table.States (659), 71, 28);
- Add_Action (Table.States (659), 104, 185);
- Table.States (659).Goto_List.Set_Capacity (53);
- Add_Goto (Table.States (659), 112, 35);
- Add_Goto (Table.States (659), 121, 37);
- Add_Goto (Table.States (659), 127, 40);
- Add_Goto (Table.States (659), 134, 45);
- Add_Goto (Table.States (659), 135, 46);
- Add_Goto (Table.States (659), 157, 391);
- Add_Goto (Table.States (659), 158, 392);
- Add_Goto (Table.States (659), 159, 821);
- Add_Goto (Table.States (659), 179, 54);
- Add_Goto (Table.States (659), 182, 55);
- Add_Goto (Table.States (659), 186, 56);
- Add_Goto (Table.States (659), 193, 58);
- Add_Goto (Table.States (659), 206, 60);
- Add_Goto (Table.States (659), 207, 61);
- Add_Goto (Table.States (659), 209, 62);
- Add_Goto (Table.States (659), 210, 63);
- Add_Goto (Table.States (659), 213, 64);
- Add_Goto (Table.States (659), 214, 65);
- Add_Goto (Table.States (659), 215, 66);
- Add_Goto (Table.States (659), 216, 67);
- Add_Goto (Table.States (659), 219, 69);
- Add_Goto (Table.States (659), 223, 71);
- Add_Goto (Table.States (659), 243, 74);
- Add_Goto (Table.States (659), 244, 75);
- Add_Goto (Table.States (659), 245, 76);
- Add_Goto (Table.States (659), 246, 77);
- Add_Goto (Table.States (659), 247, 78);
- Add_Goto (Table.States (659), 248, 79);
- Add_Goto (Table.States (659), 249, 80);
- Add_Goto (Table.States (659), 250, 81);
- Add_Goto (Table.States (659), 251, 82);
- Add_Goto (Table.States (659), 257, 394);
- Add_Goto (Table.States (659), 259, 84);
- Add_Goto (Table.States (659), 260, 85);
- Add_Goto (Table.States (659), 262, 87);
- Add_Goto (Table.States (659), 263, 88);
- Add_Goto (Table.States (659), 264, 89);
- Add_Goto (Table.States (659), 265, 90);
- Add_Goto (Table.States (659), 271, 91);
- Add_Goto (Table.States (659), 281, 94);
- Add_Goto (Table.States (659), 289, 95);
- Add_Goto (Table.States (659), 304, 102);
- Add_Goto (Table.States (659), 305, 103);
- Add_Goto (Table.States (659), 307, 105);
- Add_Goto (Table.States (659), 308, 106);
- Add_Goto (Table.States (659), 309, 107);
- Add_Goto (Table.States (659), 311, 108);
- Add_Goto (Table.States (659), 313, 109);
- Add_Goto (Table.States (659), 316, 111);
- Add_Goto (Table.States (659), 317, 112);
- Add_Goto (Table.States (659), 319, 113);
- Add_Goto (Table.States (659), 325, 115);
- Add_Goto (Table.States (659), 331, 116);
- Table.States (659).Kernel := To_Vector (((247, 35, 3, False),
(247, 35, 2, False)));
- Table.States (659).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 159, 0)));
- Table.States (660).Action_List.Set_Capacity (6);
- Add_Action (Table.States (660), 74, 337);
- Add_Action (Table.States (660), 76, 235);
- Add_Action (Table.States (660), 84, 237);
- Add_Action (Table.States (660), 96, Reduce, (122, 1), 0, null,
null);
- Add_Action (Table.States (660), 101, 239);
- Add_Action (Table.States (660), 102, 240);
- Table.States (660).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (660), 115, 241);
- Add_Goto (Table.States (660), 122, 822);
- Add_Goto (Table.States (660), 322, 242);
- Table.States (660).Kernel := To_Vector (((128, 239, 2, True),
(213, 239, 1, False), (239, 239, 5, True),
- (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (660).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- end Subr_12;
- procedure Subr_13
- is begin
- Table.States (661).Action_List.Set_Capacity (1);
- Add_Action (Table.States (661), 96, 823);
- Table.States (661).Kernel := To_Vector ((0 => (250, 122, 1,
False)));
- Table.States (661).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 823)));
- Table.States (662).Action_List.Set_Capacity (2);
- Add_Action (Table.States (662), 24, 824);
- Add_Action (Table.States (662), 49, 825);
- Table.States (662).Kernel := To_Vector (((251, 159, 2, False),
(251, 159, 1, False)));
- Table.States (662).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 824)));
- Table.States (663).Action_List.Set_Capacity (1);
- Add_Action (Table.States (663), 96, 826);
- Table.States (663).Kernel := To_Vector ((0 => (257, 77, 1,
False)));
- Table.States (663).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 826)));
- Table.States (664).Action_List.Set_Capacity (1);
- Add_Action (Table.States (664), 96, 827);
- Table.States (664).Kernel := To_Vector ((0 => (257, 77, 1,
False)));
- Table.States (664).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 827)));
- Table.States (665).Action_List.Set_Capacity (2);
- Add_Action (Table.States (665), 74, 337);
- Add_Action (Table.States (665), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (665).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (665), 122, 828);
- Table.States (665).Kernel := To_Vector ((0 => (265, 60, 1,
False)));
- Table.States (665).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (666).Action_List.Set_Capacity (7);
- Add_Action (Table.States (666), 24, Reduce, (269, 1), 0, null,
null);
- Add_Action (Table.States (666), 25, 829);
- Add_Action (Table.States (666), 28, 183);
- Add_Action (Table.States (666), 29, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (666), 40, 12);
- Add_Action (Table.States (666), 46, 14);
- Add_Action (Table.States (666), 50, Reduce, (246, 2), 0, null,
null);
- Table.States (666).Goto_List.Set_Capacity (15);
- Add_Goto (Table.States (666), 121, 830);
- Add_Goto (Table.States (666), 127, 40);
- Add_Goto (Table.States (666), 176, 831);
- Add_Goto (Table.States (666), 182, 55);
- Add_Goto (Table.States (666), 193, 832);
- Add_Goto (Table.States (666), 207, 61);
- Add_Goto (Table.States (666), 243, 833);
- Add_Goto (Table.States (666), 246, 834);
- Add_Goto (Table.States (666), 262, 87);
- Add_Goto (Table.States (666), 267, 835);
- Add_Goto (Table.States (666), 268, 836);
- Add_Goto (Table.States (666), 269, 837);
- Add_Goto (Table.States (666), 281, 94);
- Add_Goto (Table.States (666), 307, 838);
- Add_Goto (Table.States (666), 309, 839);
- Table.States (666).Kernel := To_Vector ((0 => (264, 35, 2,
False)));
- Table.States (666).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 269, 0)));
+ Table.States (663).Kernel := To_Vector ((0 => (333, 97, 0,
False)));
+ Table.States (663).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 333, 5)));
+ Table.States (664).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (664), 74, 338);
+ Add_Action (Table.States (664), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (664).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (664), 123, 828);
+ Table.States (664).Kernel := To_Vector ((0 => (249, 60, 1,
False)));
+ Table.States (664).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (665).Action_List.Set_Capacity (17);
+ Add_Action (Table.States (665), 13, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (665), 24, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (665), 25, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (665), 28, 184);
+ Add_Action (Table.States (665), 29, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (665), 30, 8);
+ Add_Action (Table.States (665), 40, 12);
+ Add_Action (Table.States (665), 46, 14);
+ Add_Action (Table.States (665), 47, 15);
+ Add_Action (Table.States (665), 48, 16);
+ Add_Action (Table.States (665), 50, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (665), 51, 19);
+ Add_Action (Table.States (665), 63, 25);
+ Add_Action (Table.States (665), 66, 26);
+ Add_Action (Table.States (665), 69, 27);
+ Add_Action (Table.States (665), 71, 28);
+ Add_Action (Table.States (665), 105, 186);
+ Table.States (665).Goto_List.Set_Capacity (53);
+ Add_Goto (Table.States (665), 113, 36);
+ Add_Goto (Table.States (665), 122, 38);
+ Add_Goto (Table.States (665), 128, 41);
+ Add_Goto (Table.States (665), 135, 46);
+ Add_Goto (Table.States (665), 136, 47);
+ Add_Goto (Table.States (665), 158, 392);
+ Add_Goto (Table.States (665), 159, 393);
+ Add_Goto (Table.States (665), 160, 829);
+ Add_Goto (Table.States (665), 180, 55);
+ Add_Goto (Table.States (665), 183, 56);
+ Add_Goto (Table.States (665), 187, 57);
+ Add_Goto (Table.States (665), 194, 59);
+ Add_Goto (Table.States (665), 207, 61);
+ Add_Goto (Table.States (665), 208, 62);
+ Add_Goto (Table.States (665), 210, 63);
+ Add_Goto (Table.States (665), 211, 64);
+ Add_Goto (Table.States (665), 214, 65);
+ Add_Goto (Table.States (665), 215, 66);
+ Add_Goto (Table.States (665), 216, 67);
+ Add_Goto (Table.States (665), 217, 68);
+ Add_Goto (Table.States (665), 220, 70);
+ Add_Goto (Table.States (665), 224, 72);
+ Add_Goto (Table.States (665), 244, 75);
+ Add_Goto (Table.States (665), 245, 76);
+ Add_Goto (Table.States (665), 246, 77);
+ Add_Goto (Table.States (665), 247, 78);
+ Add_Goto (Table.States (665), 248, 79);
+ Add_Goto (Table.States (665), 249, 80);
+ Add_Goto (Table.States (665), 250, 81);
+ Add_Goto (Table.States (665), 251, 82);
+ Add_Goto (Table.States (665), 252, 83);
+ Add_Goto (Table.States (665), 258, 395);
+ Add_Goto (Table.States (665), 260, 85);
+ Add_Goto (Table.States (665), 261, 86);
+ Add_Goto (Table.States (665), 263, 88);
+ Add_Goto (Table.States (665), 264, 89);
+ Add_Goto (Table.States (665), 265, 90);
+ Add_Goto (Table.States (665), 266, 91);
+ Add_Goto (Table.States (665), 272, 92);
+ Add_Goto (Table.States (665), 282, 95);
+ Add_Goto (Table.States (665), 290, 96);
+ Add_Goto (Table.States (665), 305, 103);
+ Add_Goto (Table.States (665), 306, 104);
+ Add_Goto (Table.States (665), 308, 106);
+ Add_Goto (Table.States (665), 309, 107);
+ Add_Goto (Table.States (665), 310, 108);
+ Add_Goto (Table.States (665), 312, 109);
+ Add_Goto (Table.States (665), 314, 110);
+ Add_Goto (Table.States (665), 317, 112);
+ Add_Goto (Table.States (665), 318, 113);
+ Add_Goto (Table.States (665), 320, 114);
+ Add_Goto (Table.States (665), 326, 116);
+ Add_Goto (Table.States (665), 332, 117);
+ Table.States (665).Kernel := To_Vector (((248, 35, 3, False),
(248, 35, 2, False)));
+ Table.States (665).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 160, 0)));
+ Table.States (666).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (666), 74, 338);
+ Add_Action (Table.States (666), 76, 236);
+ Add_Action (Table.States (666), 85, 238);
+ Add_Action (Table.States (666), 97, Reduce, (123, 1), 0, null,
null);
+ Add_Action (Table.States (666), 102, 240);
+ Add_Action (Table.States (666), 103, 241);
+ Table.States (666).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (666), 116, 242);
+ Add_Goto (Table.States (666), 123, 830);
+ Add_Goto (Table.States (666), 323, 243);
+ Table.States (666).Kernel := To_Vector (((129, 240, 2, True),
(214, 240, 1, False), (240, 240, 5, True),
+ (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (666).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
Table.States (667).Action_List.Set_Capacity (1);
- Add_Action (Table.States (667), 35, 840);
- Table.States (667).Kernel := To_Vector (((271, 122, 6, False),
(271, 122, 3, False)));
- Table.States (667).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 840)));
- Table.States (668).Action_List.Set_Capacity (3);
- Add_Action (Table.States (668), 104, 119);
- Add_Action (Table.States (668), 105, 33);
- Add_Action (Table.States (668), 106, 34);
- Table.States (668).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (668), 128, 41);
- Add_Goto (Table.States (668), 227, 841);
- Add_Goto (Table.States (668), 239, 842);
- Add_Goto (Table.States (668), 272, 92);
- Add_Goto (Table.States (668), 293, 97);
- Table.States (668).Kernel := To_Vector ((0 => (304, 39, 4,
False)));
- Table.States (668).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (669).Action_List.Set_Capacity (2);
- Add_Action (Table.States (669), 24, 843);
- Add_Action (Table.States (669), 49, 844);
- Table.States (669).Kernel := To_Vector (((266, 159, 2, False),
(266, 159, 1, False)));
- Table.States (669).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 843)));
+ Add_Action (Table.States (667), 97, 831);
+ Table.States (667).Kernel := To_Vector ((0 => (251, 123, 1,
False)));
+ Table.States (667).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 831)));
+ Table.States (668).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (668), 24, 832);
+ Add_Action (Table.States (668), 49, 833);
+ Table.States (668).Kernel := To_Vector (((252, 160, 2, False),
(252, 160, 1, False)));
+ Table.States (668).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 832)));
+ Table.States (669).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (669), 97, 834);
+ Table.States (669).Kernel := To_Vector ((0 => (258, 77, 1,
False)));
+ Table.States (669).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 834)));
Table.States (670).Action_List.Set_Capacity (1);
- Add_Action (Table.States (670), 96, 845);
- Table.States (670).Kernel := To_Vector ((0 => (304, 266, 1,
False)));
- Table.States (670).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 845)));
- Table.States (671).Action_List.Set_Capacity (46);
- Add_Action (Table.States (671), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (276, 0), 5, raise_statement_0'Access, null);
- Table.States (671).Kernel := To_Vector ((0 => (276, 96, 0,
False)));
- Table.States (671).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 276, 5)));
- Table.States (672).Action_List.Set_Capacity (46);
- Add_Action (Table.States (672), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (290, 0), 5, requeue_statement_0'Access, null);
- Table.States (672).Kernel := To_Vector ((0 => (290, 96, 0,
False)));
- Table.States (672).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 290, 5)));
- Table.States (673).Action_List.Set_Capacity (5);
- Add_Action (Table.States (673), 7, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (673), 40, 744);
- Add_Action (Table.States (673), 104, 119);
- Add_Action (Table.States (673), 105, 33);
- Add_Action (Table.States (673), 106, 34);
- Table.States (673).Goto_List.Set_Capacity (8);
- Add_Goto (Table.States (673), 114, 846);
- Add_Goto (Table.States (673), 128, 41);
- Add_Goto (Table.States (673), 239, 484);
- Add_Goto (Table.States (673), 241, 723);
- Add_Goto (Table.States (673), 272, 92);
- Add_Goto (Table.States (673), 292, 847);
- Add_Goto (Table.States (673), 293, 97);
- Add_Goto (Table.States (673), 314, 848);
- Table.States (673).Kernel := To_Vector (((194, 154, 2, False),
(194, 154, 1, False)));
- Table.States (673).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (674).Action_List.Set_Capacity (1);
- Add_Action (Table.States (674), 58, 849);
- Table.States (674).Kernel := To_Vector ((0 => (196, 24, 2,
False)));
- Table.States (674).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 58, 849)));
- Table.States (675).Action_List.Set_Capacity (1);
- Add_Action (Table.States (675), 14, 850);
- Table.States (675).Kernel := To_Vector (((247, 47, 6, False),
(247, 47, 5, False)));
- Table.States (675).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 14, 850)));
+ Add_Action (Table.States (670), 97, 835);
+ Table.States (670).Kernel := To_Vector ((0 => (258, 77, 1,
False)));
+ Table.States (670).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 835)));
+ Table.States (671).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (671), 74, 338);
+ Add_Action (Table.States (671), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (671).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (671), 123, 836);
+ Table.States (671).Kernel := To_Vector ((0 => (266, 60, 1,
False)));
+ Table.States (671).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (672).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (672), 24, Reduce, (270, 1), 0, null,
null);
+ Add_Action (Table.States (672), 25, 837);
+ Add_Action (Table.States (672), 28, 184);
+ Add_Action (Table.States (672), 29, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (672), 40, 12);
+ Add_Action (Table.States (672), 46, 14);
+ Add_Action (Table.States (672), 50, Reduce, (247, 2), 0, null,
null);
+ Table.States (672).Goto_List.Set_Capacity (15);
+ Add_Goto (Table.States (672), 122, 838);
+ Add_Goto (Table.States (672), 128, 41);
+ Add_Goto (Table.States (672), 177, 839);
+ Add_Goto (Table.States (672), 183, 56);
+ Add_Goto (Table.States (672), 194, 840);
+ Add_Goto (Table.States (672), 208, 62);
+ Add_Goto (Table.States (672), 244, 841);
+ Add_Goto (Table.States (672), 247, 842);
+ Add_Goto (Table.States (672), 263, 88);
+ Add_Goto (Table.States (672), 268, 843);
+ Add_Goto (Table.States (672), 269, 844);
+ Add_Goto (Table.States (672), 270, 845);
+ Add_Goto (Table.States (672), 282, 95);
+ Add_Goto (Table.States (672), 308, 846);
+ Add_Goto (Table.States (672), 310, 847);
+ Table.States (672).Kernel := To_Vector ((0 => (265, 35, 2,
False)));
+ Table.States (672).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 270, 0)));
+ Table.States (673).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (673), 35, 848);
+ Table.States (673).Kernel := To_Vector (((272, 123, 6, False),
(272, 123, 3, False)));
+ Table.States (673).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 848)));
+ Table.States (674).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (674), 79, 31);
+ Add_Action (Table.States (674), 105, 120);
+ Add_Action (Table.States (674), 106, 34);
+ Add_Action (Table.States (674), 107, 35);
+ Table.States (674).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (674), 129, 42);
+ Add_Goto (Table.States (674), 228, 849);
+ Add_Goto (Table.States (674), 240, 850);
+ Add_Goto (Table.States (674), 273, 93);
+ Add_Goto (Table.States (674), 294, 98);
+ Table.States (674).Kernel := To_Vector ((0 => (305, 39, 4,
False)));
+ Table.States (674).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (675).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (675), 24, 851);
+ Add_Action (Table.States (675), 49, 852);
+ Table.States (675).Kernel := To_Vector (((267, 160, 2, False),
(267, 160, 1, False)));
+ Table.States (675).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 851)));
Table.States (676).Action_List.Set_Capacity (1);
- Add_Action (Table.States (676), 14, 851);
- Table.States (676).Kernel := To_Vector ((0 => (264, 51, 5,
False)));
- Table.States (676).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 14, 851)));
- Table.States (677).Action_List.Set_Capacity (1);
- Add_Action (Table.States (677), 14, 852);
- Table.States (677).Kernel := To_Vector ((0 => (316, 66, 6,
False)));
- Table.States (677).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 14, 852)));
- Table.States (678).Action_List.Set_Capacity (2);
- Add_Action (Table.States (678), 29, 7);
- Add_Action (Table.States (678), 50, 18);
- Table.States (678).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (678), 207, 61);
- Add_Goto (Table.States (678), 262, 87);
- Add_Goto (Table.States (678), 312, 853);
- Table.States (678).Kernel := To_Vector ((0 => (307, 246, 6,
False)));
- Table.States (678).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 50, 18)));
- Table.States (679).Action_List.Set_Capacity (39);
- Add_Action (Table.States (679), (4, 5, 13, 15, 17, 18, 25, 27, 28,
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
- 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93,
104, 105, 106, 107), (315, 0), 5,
- subunit_0'Access, null);
- Table.States (679).Kernel := To_Vector ((0 => (315, 263, 0,
False)));
- Table.States (679).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 315, 5)));
+ Add_Action (Table.States (676), 97, 853);
+ Table.States (676).Kernel := To_Vector ((0 => (305, 267, 1,
False)));
+ Table.States (676).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 853)));
+ Table.States (677).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (677), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (277, 0), 5, raise_statement_0'Access, null);
+ Table.States (677).Kernel := To_Vector ((0 => (277, 97, 0,
False)));
+ Table.States (677).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 277, 5)));
+ Table.States (678).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (678), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (291, 0), 5, requeue_statement_0'Access, null);
+ Table.States (678).Kernel := To_Vector ((0 => (291, 97, 0,
False)));
+ Table.States (678).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 291, 5)));
+ Table.States (679).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (679), 7, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (679), 40, 750);
+ Add_Action (Table.States (679), 79, 31);
+ Add_Action (Table.States (679), 105, 120);
+ Add_Action (Table.States (679), 106, 34);
+ Add_Action (Table.States (679), 107, 35);
+ Table.States (679).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (679), 115, 854);
+ Add_Goto (Table.States (679), 129, 42);
+ Add_Goto (Table.States (679), 240, 487);
+ Add_Goto (Table.States (679), 242, 729);
+ Add_Goto (Table.States (679), 273, 93);
+ Add_Goto (Table.States (679), 293, 855);
+ Add_Goto (Table.States (679), 294, 98);
+ Add_Goto (Table.States (679), 315, 856);
+ Table.States (679).Kernel := To_Vector (((195, 155, 2, False),
(195, 155, 1, False)));
+ Table.States (679).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
Table.States (680).Action_List.Set_Capacity (1);
- Add_Action (Table.States (680), 96, 854);
- Table.States (680).Kernel := To_Vector ((0 => (295, 67, 1,
False)));
- Table.States (680).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 854)));
- Table.States (681).Action_List.Set_Capacity (25);
- Add_Action (Table.States (681), 4, 1);
- Add_Action (Table.States (681), 5, 2);
- Add_Action (Table.States (681), 13, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (681), 15, 3);
- Add_Action (Table.States (681), 17, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (681), 18, 4);
- Add_Action (Table.States (681), 22, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (681), 24, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (681), 27, 5);
- Add_Action (Table.States (681), 28, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (681), 31, 9);
- Add_Action (Table.States (681), 32, 10);
- Add_Action (Table.States (681), 37, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (681), 41, 13);
- Add_Action (Table.States (681), 43, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (681), 48, 16);
- Add_Action (Table.States (681), 52, 20);
- Add_Action (Table.States (681), 57, 21);
- Add_Action (Table.States (681), 58, 22);
- Add_Action (Table.States (681), 61, 24);
- Add_Action (Table.States (681), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (681), 93, 31);
- Add_Action (Table.States (681), 104, 360);
- Add_Action (Table.States (681), 105, 33);
- Add_Action (Table.States (681), 106, 34);
- Table.States (681).Goto_List.Set_Capacity (31);
- Add_Goto (Table.States (681), 113, 36);
- Add_Goto (Table.States (681), 123, 38);
- Add_Goto (Table.States (681), 126, 39);
- Add_Goto (Table.States (681), 128, 41);
- Add_Goto (Table.States (681), 131, 42);
- Add_Goto (Table.States (681), 132, 43);
- Add_Goto (Table.States (681), 133, 44);
- Add_Goto (Table.States (681), 139, 47);
- Add_Goto (Table.States (681), 151, 50);
- Add_Goto (Table.States (681), 152, 51);
- Add_Goto (Table.States (681), 161, 53);
- Add_Goto (Table.States (681), 190, 57);
- Add_Goto (Table.States (681), 196, 59);
- Add_Goto (Table.States (681), 217, 68);
- Add_Goto (Table.States (681), 222, 70);
- Add_Goto (Table.States (681), 232, 72);
- Add_Goto (Table.States (681), 239, 73);
- Add_Goto (Table.States (681), 257, 83);
- Add_Goto (Table.States (681), 261, 86);
- Add_Goto (Table.States (681), 272, 92);
- Add_Goto (Table.States (681), 276, 93);
- Add_Goto (Table.States (681), 290, 96);
- Add_Goto (Table.States (681), 293, 97);
- Add_Goto (Table.States (681), 294, 98);
- Add_Goto (Table.States (681), 298, 99);
- Add_Goto (Table.States (681), 299, 361);
- Add_Goto (Table.States (681), 300, 855);
- Add_Goto (Table.States (681), 302, 100);
- Add_Goto (Table.States (681), 303, 101);
- Add_Goto (Table.States (681), 306, 363);
- Add_Goto (Table.States (681), 323, 114);
- Table.States (681).Kernel := To_Vector ((0 => (295, 113, 0,
False)));
- Table.States (681).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 300, 0)));
- Table.States (682).Action_List.Set_Capacity (3);
- Add_Action (Table.States (682), (22, 24, 43), (295, 2), 4,
select_alternative_2'Access, null);
- Table.States (682).Kernel := To_Vector ((0 => (295, 160, 0,
False)));
- Table.States (682).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 295, 4)));
+ Add_Action (Table.States (680), 58, 857);
+ Table.States (680).Kernel := To_Vector ((0 => (197, 24, 2,
False)));
+ Table.States (680).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 58, 857)));
+ Table.States (681).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (681), 14, 858);
+ Table.States (681).Kernel := To_Vector (((248, 47, 6, False),
(248, 47, 5, False)));
+ Table.States (681).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 14, 858)));
+ Table.States (682).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (682), 14, 859);
+ Table.States (682).Kernel := To_Vector ((0 => (265, 51, 5,
False)));
+ Table.States (682).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 14, 859)));
Table.States (683).Action_List.Set_Capacity (1);
- Add_Action (Table.States (683), 61, 856);
- Table.States (683).Kernel := To_Vector ((0 => (152, 24, 2,
False)));
- Table.States (683).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 61, 856)));
- Table.States (684).Action_List.Set_Capacity (1);
- Add_Action (Table.States (684), 61, 857);
- Table.States (684).Kernel := To_Vector ((0 => (323, 24, 2,
False)));
- Table.States (684).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 61, 857)));
- Table.States (685).Action_List.Set_Capacity (3);
- Add_Action (Table.States (685), (22, 24, 43), (160, 0), 2, null,
null);
- Table.States (685).Kernel := To_Vector ((0 => (160, 300, 0,
False)));
- Table.States (685).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 160, 2)));
+ Add_Action (Table.States (683), 14, 860);
+ Table.States (683).Kernel := To_Vector ((0 => (317, 66, 6,
False)));
+ Table.States (683).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 14, 860)));
+ Table.States (684).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (684), 29, 7);
+ Add_Action (Table.States (684), 50, 18);
+ Table.States (684).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (684), 208, 62);
+ Add_Goto (Table.States (684), 263, 88);
+ Add_Goto (Table.States (684), 313, 861);
+ Table.States (684).Kernel := To_Vector ((0 => (308, 247, 6,
False)));
+ Table.States (684).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 50, 18)));
+ Table.States (685).Action_List.Set_Capacity (40);
+ Add_Action (Table.States (685), (4, 5, 13, 15, 17, 18, 25, 27, 28,
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
+ 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 79,
94, 105, 106, 107, 108), (316, 0), 5,
+ subunit_0'Access, null);
+ Table.States (685).Kernel := To_Vector ((0 => (316, 264, 0,
False)));
+ Table.States (685).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 316, 5)));
Table.States (686).Action_List.Set_Capacity (1);
- Add_Action (Table.States (686), 61, 858);
- Table.States (686).Kernel := To_Vector ((0 => (294, 24, 2,
False)));
- Table.States (686).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 61, 858)));
- Table.States (687).Action_List.Set_Capacity (46);
- Add_Action (Table.States (687), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (294, 1), 5, selective_accept_1'Access, null);
- Table.States (687).Kernel := To_Vector ((0 => (294, 96, 0,
False)));
- Table.States (687).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 294, 5)));
- Table.States (688).Action_List.Set_Capacity (1);
- Add_Action (Table.States (688), 24, 859);
- Table.States (688).Kernel := To_Vector ((0 => (126, 300, 3,
False)));
- Table.States (688).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 859)));
+ Add_Action (Table.States (686), 97, 862);
+ Table.States (686).Kernel := To_Vector ((0 => (296, 67, 1,
False)));
+ Table.States (686).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 862)));
+ Table.States (687).Action_List.Set_Capacity (26);
+ Add_Action (Table.States (687), 4, 1);
+ Add_Action (Table.States (687), 5, 2);
+ Add_Action (Table.States (687), 13, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (687), 15, 3);
+ Add_Action (Table.States (687), 17, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (687), 18, 4);
+ Add_Action (Table.States (687), 22, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (687), 24, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (687), 27, 5);
+ Add_Action (Table.States (687), 28, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (687), 31, 9);
+ Add_Action (Table.States (687), 32, 10);
+ Add_Action (Table.States (687), 37, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (687), 41, 13);
+ Add_Action (Table.States (687), 43, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (687), 48, 16);
+ Add_Action (Table.States (687), 52, 20);
+ Add_Action (Table.States (687), 57, 21);
+ Add_Action (Table.States (687), 58, 22);
+ Add_Action (Table.States (687), 61, 24);
+ Add_Action (Table.States (687), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (687), 79, 31);
+ Add_Action (Table.States (687), 94, 32);
+ Add_Action (Table.States (687), 105, 361);
+ Add_Action (Table.States (687), 106, 34);
+ Add_Action (Table.States (687), 107, 35);
+ Table.States (687).Goto_List.Set_Capacity (31);
+ Add_Goto (Table.States (687), 114, 37);
+ Add_Goto (Table.States (687), 124, 39);
+ Add_Goto (Table.States (687), 127, 40);
+ Add_Goto (Table.States (687), 129, 42);
+ Add_Goto (Table.States (687), 132, 43);
+ Add_Goto (Table.States (687), 133, 44);
+ Add_Goto (Table.States (687), 134, 45);
+ Add_Goto (Table.States (687), 140, 48);
+ Add_Goto (Table.States (687), 152, 51);
+ Add_Goto (Table.States (687), 153, 52);
+ Add_Goto (Table.States (687), 162, 54);
+ Add_Goto (Table.States (687), 191, 58);
+ Add_Goto (Table.States (687), 197, 60);
+ Add_Goto (Table.States (687), 218, 69);
+ Add_Goto (Table.States (687), 223, 71);
+ Add_Goto (Table.States (687), 233, 73);
+ Add_Goto (Table.States (687), 240, 74);
+ Add_Goto (Table.States (687), 258, 84);
+ Add_Goto (Table.States (687), 262, 87);
+ Add_Goto (Table.States (687), 273, 93);
+ Add_Goto (Table.States (687), 277, 94);
+ Add_Goto (Table.States (687), 291, 97);
+ Add_Goto (Table.States (687), 294, 98);
+ Add_Goto (Table.States (687), 295, 99);
+ Add_Goto (Table.States (687), 299, 100);
+ Add_Goto (Table.States (687), 300, 362);
+ Add_Goto (Table.States (687), 301, 863);
+ Add_Goto (Table.States (687), 303, 101);
+ Add_Goto (Table.States (687), 304, 102);
+ Add_Goto (Table.States (687), 307, 364);
+ Add_Goto (Table.States (687), 324, 115);
+ Table.States (687).Kernel := To_Vector ((0 => (296, 114, 0,
False)));
+ Table.States (687).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 301, 0)));
+ Table.States (688).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (688), (22, 24, 43), (296, 2), 4,
select_alternative_2'Access, null);
+ Table.States (688).Kernel := To_Vector ((0 => (296, 161, 0,
False)));
+ Table.States (688).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 296, 4)));
Table.States (689).Action_List.Set_Capacity (1);
- Add_Action (Table.States (689), 96, 860);
- Table.States (689).Kernel := To_Vector ((0 => (313, 122, 1,
False)));
- Table.States (689).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 860)));
- Table.States (690).Action_List.Set_Capacity (2);
- Add_Action (Table.States (690), 74, 337);
- Add_Action (Table.States (690), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (690).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (690), 122, 861);
- Table.States (690).Kernel := To_Vector ((0 => (317, 60, 1,
False)));
- Table.States (690).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (691).Action_List.Set_Capacity (16);
- Add_Action (Table.States (691), 13, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (691), 25, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (691), 28, 183);
- Add_Action (Table.States (691), 29, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (691), 30, 8);
- Add_Action (Table.States (691), 40, 12);
- Add_Action (Table.States (691), 46, 14);
- Add_Action (Table.States (691), 47, 15);
- Add_Action (Table.States (691), 48, 16);
- Add_Action (Table.States (691), 50, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (691), 51, 19);
- Add_Action (Table.States (691), 63, 25);
- Add_Action (Table.States (691), 66, 26);
- Add_Action (Table.States (691), 69, 27);
- Add_Action (Table.States (691), 71, 28);
- Add_Action (Table.States (691), 104, 185);
- Table.States (691).Goto_List.Set_Capacity (53);
- Add_Goto (Table.States (691), 112, 35);
- Add_Goto (Table.States (691), 121, 37);
- Add_Goto (Table.States (691), 127, 40);
- Add_Goto (Table.States (691), 134, 45);
- Add_Goto (Table.States (691), 135, 46);
- Add_Goto (Table.States (691), 157, 391);
- Add_Goto (Table.States (691), 158, 392);
- Add_Goto (Table.States (691), 159, 862);
- Add_Goto (Table.States (691), 179, 54);
- Add_Goto (Table.States (691), 182, 55);
- Add_Goto (Table.States (691), 186, 56);
- Add_Goto (Table.States (691), 193, 58);
- Add_Goto (Table.States (691), 206, 60);
- Add_Goto (Table.States (691), 207, 61);
- Add_Goto (Table.States (691), 209, 62);
- Add_Goto (Table.States (691), 210, 63);
- Add_Goto (Table.States (691), 213, 64);
- Add_Goto (Table.States (691), 214, 65);
- Add_Goto (Table.States (691), 215, 66);
- Add_Goto (Table.States (691), 216, 67);
- Add_Goto (Table.States (691), 219, 69);
- Add_Goto (Table.States (691), 223, 71);
- Add_Goto (Table.States (691), 243, 74);
- Add_Goto (Table.States (691), 244, 75);
- Add_Goto (Table.States (691), 245, 76);
- Add_Goto (Table.States (691), 246, 77);
- Add_Goto (Table.States (691), 247, 78);
- Add_Goto (Table.States (691), 248, 79);
- Add_Goto (Table.States (691), 249, 80);
- Add_Goto (Table.States (691), 250, 81);
- Add_Goto (Table.States (691), 251, 82);
- Add_Goto (Table.States (691), 257, 394);
- Add_Goto (Table.States (691), 259, 84);
- Add_Goto (Table.States (691), 260, 85);
- Add_Goto (Table.States (691), 262, 87);
- Add_Goto (Table.States (691), 263, 88);
- Add_Goto (Table.States (691), 264, 89);
- Add_Goto (Table.States (691), 265, 90);
- Add_Goto (Table.States (691), 271, 91);
- Add_Goto (Table.States (691), 281, 94);
- Add_Goto (Table.States (691), 289, 95);
- Add_Goto (Table.States (691), 304, 102);
- Add_Goto (Table.States (691), 305, 103);
- Add_Goto (Table.States (691), 307, 105);
- Add_Goto (Table.States (691), 308, 106);
- Add_Goto (Table.States (691), 309, 107);
- Add_Goto (Table.States (691), 311, 108);
- Add_Goto (Table.States (691), 313, 109);
- Add_Goto (Table.States (691), 316, 111);
- Add_Goto (Table.States (691), 317, 112);
- Add_Goto (Table.States (691), 319, 113);
- Add_Goto (Table.States (691), 325, 115);
- Add_Goto (Table.States (691), 331, 116);
- Table.States (691).Kernel := To_Vector ((0 => (316, 35, 3,
False)));
- Table.States (691).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 159, 0)));
- Table.States (692).Action_List.Set_Capacity (2);
- Add_Action (Table.States (692), 35, 863);
- Add_Action (Table.States (692), 96, 864);
- Table.States (692).Kernel := To_Vector (((319, 122, 6, False),
(319, 122, 3, False), (319, 122, 1,
- False)));
- Table.States (692).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 864)));
- Table.States (693).Action_List.Set_Capacity (3);
- Add_Action (Table.States (693), 104, 119);
- Add_Action (Table.States (693), 105, 33);
- Add_Action (Table.States (693), 106, 34);
- Table.States (693).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (693), 128, 41);
- Add_Goto (Table.States (693), 227, 865);
- Add_Goto (Table.States (693), 239, 842);
- Add_Goto (Table.States (693), 272, 92);
- Add_Goto (Table.States (693), 293, 97);
- Table.States (693).Kernel := To_Vector ((0 => (305, 39, 4,
False)));
- Table.States (693).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (694).Action_List.Set_Capacity (2);
- Add_Action (Table.States (694), 24, Reduce, (318, 1), 1,
task_definition_1'Access, null);
- Add_Action (Table.States (694), 49, 866);
- Table.States (694).Kernel := To_Vector (((318, 159, 1, False),
(318, 159, 0, False)));
- Table.States (694).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 318, 1)));
+ Add_Action (Table.States (689), 61, 864);
+ Table.States (689).Kernel := To_Vector ((0 => (153, 24, 2,
False)));
+ Table.States (689).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 61, 864)));
+ Table.States (690).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (690), 61, 865);
+ Table.States (690).Kernel := To_Vector ((0 => (324, 24, 2,
False)));
+ Table.States (690).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 61, 865)));
+ Table.States (691).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (691), (22, 24, 43), (161, 0), 2, null,
null);
+ Table.States (691).Kernel := To_Vector ((0 => (161, 301, 0,
False)));
+ Table.States (691).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 161, 2)));
+ Table.States (692).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (692), 61, 866);
+ Table.States (692).Kernel := To_Vector ((0 => (295, 24, 2,
False)));
+ Table.States (692).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 61, 866)));
+ Table.States (693).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (693), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (295, 1), 5, selective_accept_1'Access, null);
+ Table.States (693).Kernel := To_Vector ((0 => (295, 97, 0,
False)));
+ Table.States (693).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 295, 5)));
+ Table.States (694).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (694), 24, 867);
+ Table.States (694).Kernel := To_Vector ((0 => (127, 301, 3,
False)));
+ Table.States (694).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 867)));
Table.States (695).Action_List.Set_Capacity (1);
- Add_Action (Table.States (695), 24, 867);
- Table.States (695).Kernel := To_Vector ((0 => (305, 318, 2,
False)));
- Table.States (695).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 867)));
- Table.States (696).Action_List.Set_Capacity (3);
- Add_Action (Table.States (696), (35, 74, 96), (169, 0), 3, null,
null);
- Table.States (696).Kernel := To_Vector ((0 => (169, 77, 0,
False)));
- Table.States (696).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 169, 3)));
- Table.States (697).Action_List.Set_Capacity (3);
- Add_Action (Table.States (697), (35, 74, 96), (169, 1), 3,
discriminant_part_opt_1'Access, null);
- Table.States (697).Kernel := To_Vector ((0 => (169, 77, 0,
False)));
- Table.States (697).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 169, 3)));
- Table.States (698).Action_List.Set_Capacity (3);
- Add_Action (Table.States (698), 77, Reduce, (170, 4), 0, null,
null);
- Add_Action (Table.States (698), 96, Reduce, (170, 4), 0, null,
null);
- Add_Action (Table.States (698), 104, 164);
- Table.States (698).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (698), 170, 868);
- Add_Goto (Table.States (698), 219, 547);
- Table.States (698).Kernel := To_Vector ((0 => (171, 96, 0, True)));
- Table.States (698).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 170, 0)));
- Table.States (698).Minimal_Complete_Actions_Recursive := True;
- Table.States (699).Action_List.Set_Capacity (5);
- Add_Action (Table.States (699), 7, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (699), 40, 869);
- Add_Action (Table.States (699), 104, 870);
- Add_Action (Table.States (699), 105, 33);
+ Add_Action (Table.States (695), 97, 868);
+ Table.States (695).Kernel := To_Vector ((0 => (314, 123, 1,
False)));
+ Table.States (695).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 868)));
+ Table.States (696).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (696), 74, 338);
+ Add_Action (Table.States (696), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (696).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (696), 123, 869);
+ Table.States (696).Kernel := To_Vector ((0 => (318, 60, 1,
False)));
+ Table.States (696).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (697).Action_List.Set_Capacity (16);
+ Add_Action (Table.States (697), 13, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (697), 25, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (697), 28, 184);
+ Add_Action (Table.States (697), 29, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (697), 30, 8);
+ Add_Action (Table.States (697), 40, 12);
+ Add_Action (Table.States (697), 46, 14);
+ Add_Action (Table.States (697), 47, 15);
+ Add_Action (Table.States (697), 48, 16);
+ Add_Action (Table.States (697), 50, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (697), 51, 19);
+ Add_Action (Table.States (697), 63, 25);
+ Add_Action (Table.States (697), 66, 26);
+ Add_Action (Table.States (697), 69, 27);
+ Add_Action (Table.States (697), 71, 28);
+ Add_Action (Table.States (697), 105, 186);
+ Table.States (697).Goto_List.Set_Capacity (53);
+ Add_Goto (Table.States (697), 113, 36);
+ Add_Goto (Table.States (697), 122, 38);
+ Add_Goto (Table.States (697), 128, 41);
+ Add_Goto (Table.States (697), 135, 46);
+ Add_Goto (Table.States (697), 136, 47);
+ Add_Goto (Table.States (697), 158, 392);
+ Add_Goto (Table.States (697), 159, 393);
+ Add_Goto (Table.States (697), 160, 870);
+ Add_Goto (Table.States (697), 180, 55);
+ Add_Goto (Table.States (697), 183, 56);
+ Add_Goto (Table.States (697), 187, 57);
+ Add_Goto (Table.States (697), 194, 59);
+ Add_Goto (Table.States (697), 207, 61);
+ Add_Goto (Table.States (697), 208, 62);
+ Add_Goto (Table.States (697), 210, 63);
+ Add_Goto (Table.States (697), 211, 64);
+ Add_Goto (Table.States (697), 214, 65);
+ Add_Goto (Table.States (697), 215, 66);
+ Add_Goto (Table.States (697), 216, 67);
+ Add_Goto (Table.States (697), 217, 68);
+ Add_Goto (Table.States (697), 220, 70);
+ Add_Goto (Table.States (697), 224, 72);
+ Add_Goto (Table.States (697), 244, 75);
+ Add_Goto (Table.States (697), 245, 76);
+ Add_Goto (Table.States (697), 246, 77);
+ Add_Goto (Table.States (697), 247, 78);
+ Add_Goto (Table.States (697), 248, 79);
+ Add_Goto (Table.States (697), 249, 80);
+ Add_Goto (Table.States (697), 250, 81);
+ Add_Goto (Table.States (697), 251, 82);
+ Add_Goto (Table.States (697), 252, 83);
+ Add_Goto (Table.States (697), 258, 395);
+ Add_Goto (Table.States (697), 260, 85);
+ Add_Goto (Table.States (697), 261, 86);
+ Add_Goto (Table.States (697), 263, 88);
+ Add_Goto (Table.States (697), 264, 89);
+ Add_Goto (Table.States (697), 265, 90);
+ Add_Goto (Table.States (697), 266, 91);
+ Add_Goto (Table.States (697), 272, 92);
+ Add_Goto (Table.States (697), 282, 95);
+ Add_Goto (Table.States (697), 290, 96);
+ Add_Goto (Table.States (697), 305, 103);
+ Add_Goto (Table.States (697), 306, 104);
+ Add_Goto (Table.States (697), 308, 106);
+ Add_Goto (Table.States (697), 309, 107);
+ Add_Goto (Table.States (697), 310, 108);
+ Add_Goto (Table.States (697), 312, 109);
+ Add_Goto (Table.States (697), 314, 110);
+ Add_Goto (Table.States (697), 317, 112);
+ Add_Goto (Table.States (697), 318, 113);
+ Add_Goto (Table.States (697), 320, 114);
+ Add_Goto (Table.States (697), 326, 116);
+ Add_Goto (Table.States (697), 332, 117);
+ Table.States (697).Kernel := To_Vector ((0 => (317, 35, 3,
False)));
+ Table.States (697).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 160, 0)));
+ Table.States (698).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (698), 35, 871);
+ Add_Action (Table.States (698), 97, 872);
+ Table.States (698).Kernel := To_Vector (((320, 123, 6, False),
(320, 123, 3, False), (320, 123, 1,
+ False)));
+ Table.States (698).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 872)));
+ Table.States (699).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (699), 79, 31);
+ Add_Action (Table.States (699), 105, 120);
Add_Action (Table.States (699), 106, 34);
- Table.States (699).Goto_List.Set_Capacity (7);
- Add_Goto (Table.States (699), 114, 871);
- Add_Goto (Table.States (699), 128, 41);
- Add_Goto (Table.States (699), 239, 872);
- Add_Goto (Table.States (699), 241, 723);
- Add_Goto (Table.States (699), 242, 873);
- Add_Goto (Table.States (699), 272, 92);
- Add_Goto (Table.States (699), 293, 874);
- Table.States (699).Kernel := To_Vector (((170, 81, 2, False),
(170, 81, 3, False), (170, 81, 1, False),
- (170, 81, 2, False)));
- Table.States (699).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 870)));
- Table.States (700).Action_List.Set_Capacity (4);
- Add_Action (Table.States (700), 36, 875);
- Add_Action (Table.States (700), 39, Reduce, (109, 2), 1, null,
null);
- Add_Conflict (Table.States (700), 39, (110, 2), 1, null, null);
- Add_Action (Table.States (700), 64, 876);
- Add_Action (Table.States (700), 65, 877);
- Table.States (700).Kernel := To_Vector (((109, 6, 1, False), (109,
6, 1, False), (109, 6, 0, False), (110,
- 6, 1, False), (110, 6, 0, False), (111, 6, 2, False), (111, 6, 1,
False)));
- Table.States (700).Minimal_Complete_Actions := To_Vector
(((Reduce, 109, 1), (Reduce, 110, 1)));
+ Add_Action (Table.States (699), 107, 35);
+ Table.States (699).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (699), 129, 42);
+ Add_Goto (Table.States (699), 228, 873);
+ Add_Goto (Table.States (699), 240, 850);
+ Add_Goto (Table.States (699), 273, 93);
+ Add_Goto (Table.States (699), 294, 98);
+ Table.States (699).Kernel := To_Vector ((0 => (306, 39, 4,
False)));
+ Table.States (699).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (700).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (700), 24, Reduce, (319, 1), 1,
task_definition_1'Access, null);
+ Add_Action (Table.States (700), 49, 874);
+ Table.States (700).Kernel := To_Vector (((319, 160, 1, False),
(319, 160, 0, False)));
+ Table.States (700).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 319, 1)));
Table.States (701).Action_List.Set_Capacity (1);
- Add_Action (Table.States (701), 76, 878);
- Table.States (701).Kernel := To_Vector (((120, 11, 7, False),
(120, 11, 7, False)));
- Table.States (701).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 76, 878)));
- Table.States (702).Action_List.Set_Capacity (16);
- Add_Action (Table.States (702), 3, 121);
- Add_Action (Table.States (702), 20, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (702), 39, 122);
- Add_Action (Table.States (702), 40, 123);
- Add_Action (Table.States (702), 41, 124);
- Add_Action (Table.States (702), 52, 125);
- Add_Action (Table.States (702), 53, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (702), 74, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (702), 76, 126);
- Add_Action (Table.States (702), 94, 127);
- Add_Action (Table.States (702), 95, 128);
- Add_Action (Table.States (702), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (702), 103, 129);
- Add_Action (Table.States (702), 104, 119);
- Add_Action (Table.States (702), 105, 33);
- Add_Action (Table.States (702), 106, 34);
- Table.States (702).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (702), 117, 130);
- Add_Goto (Table.States (702), 128, 41);
- Add_Goto (Table.States (702), 191, 131);
- Add_Goto (Table.States (702), 192, 879);
- Add_Goto (Table.States (702), 197, 133);
- Add_Goto (Table.States (702), 239, 134);
- Add_Goto (Table.States (702), 258, 135);
- Add_Goto (Table.States (702), 272, 92);
- Add_Goto (Table.States (702), 275, 136);
- Add_Goto (Table.States (702), 282, 137);
- Add_Goto (Table.States (702), 283, 138);
- Add_Goto (Table.States (702), 284, 139);
- Add_Goto (Table.States (702), 285, 140);
- Add_Goto (Table.States (702), 286, 141);
- Add_Goto (Table.States (702), 287, 142);
- Add_Goto (Table.States (702), 293, 97);
- Add_Goto (Table.States (702), 301, 143);
- Add_Goto (Table.States (702), 320, 144);
- Add_Goto (Table.States (702), 321, 145);
- Add_Goto (Table.States (702), 330, 146);
- Table.States (702).Kernel := To_Vector (((326, 19, 1, False),
(326, 19, 0, False)));
- Table.States (702).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (703).Action_List.Set_Capacity (15);
- Add_Action (Table.States (703), 3, 121);
- Add_Action (Table.States (703), 39, 122);
- Add_Action (Table.States (703), 40, 123);
- Add_Action (Table.States (703), 41, 124);
- Add_Action (Table.States (703), 52, 125);
- Add_Action (Table.States (703), 53, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (703), 74, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (703), 76, 126);
- Add_Action (Table.States (703), 94, 127);
- Add_Action (Table.States (703), 95, 128);
- Add_Action (Table.States (703), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (703), 103, 129);
- Add_Action (Table.States (703), 104, 119);
- Add_Action (Table.States (703), 105, 33);
- Add_Action (Table.States (703), 106, 34);
- Table.States (703).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (703), 117, 130);
- Add_Goto (Table.States (703), 128, 41);
- Add_Goto (Table.States (703), 191, 131);
- Add_Goto (Table.States (703), 192, 880);
- Add_Goto (Table.States (703), 197, 133);
- Add_Goto (Table.States (703), 239, 134);
- Add_Goto (Table.States (703), 258, 135);
- Add_Goto (Table.States (703), 272, 92);
- Add_Goto (Table.States (703), 275, 136);
- Add_Goto (Table.States (703), 282, 137);
- Add_Goto (Table.States (703), 283, 138);
- Add_Goto (Table.States (703), 284, 139);
- Add_Goto (Table.States (703), 285, 140);
- Add_Goto (Table.States (703), 286, 141);
- Add_Goto (Table.States (703), 287, 142);
- Add_Goto (Table.States (703), 293, 97);
- Add_Goto (Table.States (703), 301, 143);
- Add_Goto (Table.States (703), 320, 144);
- Add_Goto (Table.States (703), 321, 145);
- Add_Goto (Table.States (703), 330, 146);
- Table.States (703).Kernel := To_Vector ((0 => (326, 20, 0,
False)));
- Table.States (703).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (704).Action_List.Set_Capacity (2);
- Add_Action (Table.States (704), (74, 96), (228, 8), 1, null, null);
- Table.States (704).Kernel := To_Vector ((0 => (228, 34, 0,
False)));
- Table.States (704).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 228, 1)));
- Table.States (705).Action_List.Set_Capacity (5);
- Add_Action (Table.States (705), 34, 881);
- Add_Action (Table.States (705), 39, Reduce, (109, 3), 1, null,
null);
- Add_Conflict (Table.States (705), 39, (110, 1), 1, null, null);
- Add_Action (Table.States (705), 41, Reduce, (111, 4), 1, null,
null);
- Add_Action (Table.States (705), 49, Reduce, (111, 4), 1, null,
null);
- Add_Action (Table.States (705), 54, Reduce, (111, 4), 1, null,
null);
- Table.States (705).Kernel := To_Vector (((109, 36, 0, False),
(110, 36, 0, False), (111, 36, 0, False),
- (228, 36, 3, False), (228, 36, 1, False)));
- Table.States (705).Minimal_Complete_Actions := To_Vector
(((Reduce, 109, 1), (Reduce, 110, 1), (Reduce,
- 111, 1)));
- Table.States (706).Action_List.Set_Capacity (14);
- Add_Action (Table.States (706), 3, 121);
- Add_Action (Table.States (706), 39, 122);
- Add_Action (Table.States (706), 40, 123);
- Add_Action (Table.States (706), 41, 124);
- Add_Action (Table.States (706), 52, 125);
- Add_Action (Table.States (706), 74, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (706), 76, 126);
- Add_Action (Table.States (706), 94, 127);
- Add_Action (Table.States (706), 95, 128);
- Add_Action (Table.States (706), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (706), 103, 129);
- Add_Action (Table.States (706), 104, 119);
- Add_Action (Table.States (706), 105, 33);
- Add_Action (Table.States (706), 106, 34);
- Table.States (706).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (706), 117, 130);
- Add_Goto (Table.States (706), 128, 41);
- Add_Goto (Table.States (706), 191, 131);
- Add_Goto (Table.States (706), 192, 882);
- Add_Goto (Table.States (706), 197, 133);
- Add_Goto (Table.States (706), 239, 134);
- Add_Goto (Table.States (706), 258, 135);
- Add_Goto (Table.States (706), 272, 92);
- Add_Goto (Table.States (706), 275, 136);
- Add_Goto (Table.States (706), 282, 137);
- Add_Goto (Table.States (706), 283, 138);
- Add_Goto (Table.States (706), 284, 139);
- Add_Goto (Table.States (706), 285, 140);
- Add_Goto (Table.States (706), 286, 141);
- Add_Goto (Table.States (706), 287, 142);
- Add_Goto (Table.States (706), 293, 97);
- Add_Goto (Table.States (706), 301, 143);
- Add_Goto (Table.States (706), 320, 144);
- Add_Goto (Table.States (706), 321, 145);
- Add_Goto (Table.States (706), 330, 146);
- Table.States (706).Kernel := To_Vector ((0 => (326, 38, 0,
False)));
- Table.States (706).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
+ Add_Action (Table.States (701), 24, 875);
+ Table.States (701).Kernel := To_Vector ((0 => (306, 319, 2,
False)));
+ Table.States (701).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 875)));
+ Table.States (702).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (702), (35, 74, 97), (170, 0), 3, null,
null);
+ Table.States (702).Kernel := To_Vector ((0 => (170, 77, 0,
False)));
+ Table.States (702).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 170, 3)));
+ Table.States (703).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (703), (35, 74, 97), (170, 1), 3,
discriminant_part_opt_1'Access, null);
+ Table.States (703).Kernel := To_Vector ((0 => (170, 77, 0,
False)));
+ Table.States (703).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 170, 3)));
+ Table.States (704).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (704), 77, Reduce, (171, 4), 0, null,
null);
+ Add_Action (Table.States (704), 97, Reduce, (171, 4), 0, null,
null);
+ Add_Action (Table.States (704), 105, 165);
+ Table.States (704).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (704), 171, 876);
+ Add_Goto (Table.States (704), 220, 551);
+ Table.States (704).Kernel := To_Vector ((0 => (172, 97, 0, True)));
+ Table.States (704).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 171, 0)));
+ Table.States (704).Minimal_Complete_Actions_Recursive := True;
+ Table.States (705).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (705), 7, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (705), 40, 877);
+ Add_Action (Table.States (705), 79, 31);
+ Add_Action (Table.States (705), 105, 878);
+ Add_Action (Table.States (705), 106, 34);
+ Add_Action (Table.States (705), 107, 35);
+ Table.States (705).Goto_List.Set_Capacity (7);
+ Add_Goto (Table.States (705), 115, 879);
+ Add_Goto (Table.States (705), 129, 42);
+ Add_Goto (Table.States (705), 240, 880);
+ Add_Goto (Table.States (705), 242, 729);
+ Add_Goto (Table.States (705), 243, 881);
+ Add_Goto (Table.States (705), 273, 93);
+ Add_Goto (Table.States (705), 294, 882);
+ Table.States (705).Kernel := To_Vector (((171, 82, 2, False),
(171, 82, 3, False), (171, 82, 1, False),
+ (171, 82, 2, False)));
+ Table.States (705).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 878)));
+ end Subr_13;
+ procedure Subr_14
+ is begin
+ Table.States (706).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (706), 36, 883);
+ Add_Action (Table.States (706), 39, Reduce, (110, 2), 1, null,
null);
+ Add_Conflict (Table.States (706), 39, (111, 2), 1, null, null);
+ Add_Action (Table.States (706), 64, 884);
+ Add_Action (Table.States (706), 65, 885);
+ Table.States (706).Kernel := To_Vector (((110, 6, 1, False), (110,
6, 1, False), (110, 6, 0, False), (111,
+ 6, 1, False), (111, 6, 0, False), (112, 6, 2, False), (112, 6, 1,
False)));
+ Table.States (706).Minimal_Complete_Actions := To_Vector
(((Reduce, 110, 1), (Reduce, 111, 1)));
Table.States (707).Action_List.Set_Capacity (1);
- Add_Action (Table.States (707), 54, 883);
- Table.States (707).Kernel := To_Vector ((0 => (280, 41, 1,
False)));
- Table.States (707).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 54, 883)));
- Table.States (708).Action_List.Set_Capacity (1);
- Add_Action (Table.States (708), 34, 884);
- Table.States (708).Kernel := To_Vector (((228, 51, 3, False),
(228, 51, 1, False)));
- Table.States (708).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 34, 884)));
- Table.States (709).Action_List.Set_Capacity (11);
- Add_Action (Table.States (709), 3, 121);
- Add_Action (Table.States (709), 39, 122);
- Add_Action (Table.States (709), 40, 123);
- Add_Action (Table.States (709), 41, 124);
- Add_Action (Table.States (709), 76, 126);
- Add_Action (Table.States (709), 94, 127);
+ Add_Action (Table.States (707), 76, 886);
+ Table.States (707).Kernel := To_Vector (((121, 11, 7, False),
(121, 11, 7, False)));
+ Table.States (707).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 76, 886)));
+ Table.States (708).Action_List.Set_Capacity (17);
+ Add_Action (Table.States (708), 3, 122);
+ Add_Action (Table.States (708), 20, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (708), 39, 123);
+ Add_Action (Table.States (708), 40, 124);
+ Add_Action (Table.States (708), 41, 125);
+ Add_Action (Table.States (708), 52, 126);
+ Add_Action (Table.States (708), 53, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (708), 74, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (708), 76, 127);
+ Add_Action (Table.States (708), 79, 31);
+ Add_Action (Table.States (708), 95, 128);
+ Add_Action (Table.States (708), 96, 129);
+ Add_Action (Table.States (708), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (708), 104, 130);
+ Add_Action (Table.States (708), 105, 120);
+ Add_Action (Table.States (708), 106, 34);
+ Add_Action (Table.States (708), 107, 35);
+ Table.States (708).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (708), 118, 131);
+ Add_Goto (Table.States (708), 129, 42);
+ Add_Goto (Table.States (708), 192, 132);
+ Add_Goto (Table.States (708), 193, 887);
+ Add_Goto (Table.States (708), 198, 134);
+ Add_Goto (Table.States (708), 240, 135);
+ Add_Goto (Table.States (708), 259, 136);
+ Add_Goto (Table.States (708), 273, 93);
+ Add_Goto (Table.States (708), 276, 137);
+ Add_Goto (Table.States (708), 283, 138);
+ Add_Goto (Table.States (708), 284, 139);
+ Add_Goto (Table.States (708), 285, 140);
+ Add_Goto (Table.States (708), 286, 141);
+ Add_Goto (Table.States (708), 287, 142);
+ Add_Goto (Table.States (708), 288, 143);
+ Add_Goto (Table.States (708), 294, 98);
+ Add_Goto (Table.States (708), 302, 144);
+ Add_Goto (Table.States (708), 321, 145);
+ Add_Goto (Table.States (708), 322, 146);
+ Add_Goto (Table.States (708), 331, 147);
+ Table.States (708).Kernel := To_Vector (((327, 19, 1, False),
(327, 19, 0, False)));
+ Table.States (708).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (709).Action_List.Set_Capacity (16);
+ Add_Action (Table.States (709), 3, 122);
+ Add_Action (Table.States (709), 39, 123);
+ Add_Action (Table.States (709), 40, 124);
+ Add_Action (Table.States (709), 41, 125);
+ Add_Action (Table.States (709), 52, 126);
+ Add_Action (Table.States (709), 53, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (709), 74, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (709), 76, 127);
+ Add_Action (Table.States (709), 79, 31);
Add_Action (Table.States (709), 95, 128);
- Add_Action (Table.States (709), 103, 129);
- Add_Action (Table.States (709), 104, 119);
- Add_Action (Table.States (709), 105, 33);
+ Add_Action (Table.States (709), 96, 129);
+ Add_Action (Table.States (709), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (709), 104, 130);
+ Add_Action (Table.States (709), 105, 120);
Add_Action (Table.States (709), 106, 34);
- Table.States (709).Goto_List.Set_Capacity (11);
- Add_Goto (Table.States (709), 117, 130);
- Add_Goto (Table.States (709), 128, 41);
- Add_Goto (Table.States (709), 197, 133);
- Add_Goto (Table.States (709), 239, 134);
- Add_Goto (Table.States (709), 258, 135);
- Add_Goto (Table.States (709), 272, 92);
- Add_Goto (Table.States (709), 293, 97);
- Add_Goto (Table.States (709), 301, 885);
- Add_Goto (Table.States (709), 320, 144);
+ Add_Action (Table.States (709), 107, 35);
+ Table.States (709).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (709), 118, 131);
+ Add_Goto (Table.States (709), 129, 42);
+ Add_Goto (Table.States (709), 192, 132);
+ Add_Goto (Table.States (709), 193, 888);
+ Add_Goto (Table.States (709), 198, 134);
+ Add_Goto (Table.States (709), 240, 135);
+ Add_Goto (Table.States (709), 259, 136);
+ Add_Goto (Table.States (709), 273, 93);
+ Add_Goto (Table.States (709), 276, 137);
+ Add_Goto (Table.States (709), 283, 138);
+ Add_Goto (Table.States (709), 284, 139);
+ Add_Goto (Table.States (709), 285, 140);
+ Add_Goto (Table.States (709), 286, 141);
+ Add_Goto (Table.States (709), 287, 142);
+ Add_Goto (Table.States (709), 288, 143);
+ Add_Goto (Table.States (709), 294, 98);
+ Add_Goto (Table.States (709), 302, 144);
Add_Goto (Table.States (709), 321, 145);
- Add_Goto (Table.States (709), 330, 146);
- Table.States (709).Kernel := To_Vector ((0 => (326, 53, 3,
False)));
- Table.States (709).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
- Table.States (710).Action_List.Set_Capacity (5);
- Add_Action (Table.States (710), 15, 886);
- Add_Action (Table.States (710), 24, Reduce, (150, 1), 0, null,
null);
- Add_Action (Table.States (710), 28, 183);
- Add_Action (Table.States (710), 41, 887);
- Add_Action (Table.States (710), 104, 164);
- Table.States (710).Goto_List.Set_Capacity (10);
- Add_Goto (Table.States (710), 121, 888);
- Add_Goto (Table.States (710), 127, 40);
- Add_Goto (Table.States (710), 146, 889);
- Add_Goto (Table.States (710), 148, 890);
- Add_Goto (Table.States (710), 149, 891);
- Add_Goto (Table.States (710), 150, 892);
- Add_Goto (Table.States (710), 182, 55);
- Add_Goto (Table.States (710), 219, 893);
- Add_Goto (Table.States (710), 281, 94);
- Add_Goto (Table.States (710), 327, 894);
- Table.States (710).Kernel := To_Vector ((0 => (280, 54, 2,
False)));
- Table.States (710).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 150, 0)));
- Table.States (711).Action_List.Set_Capacity (2);
- Add_Action (Table.States (711), 34, 895);
- Add_Action (Table.States (711), 39, Reduce, (109, 4), 1, null,
null);
- Table.States (711).Kernel := To_Vector (((109, 64, 0, False),
(228, 64, 3, False), (228, 64, 1, False)));
- Table.States (711).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 109, 1)));
- Table.States (712).Action_List.Set_Capacity (5);
- Add_Action (Table.States (712), 36, 896);
- Add_Action (Table.States (712), 41, Reduce, (111, 3), 1, null,
null);
- Add_Action (Table.States (712), 49, Reduce, (111, 3), 1, null,
null);
- Add_Action (Table.States (712), 54, Reduce, (111, 3), 1, null,
null);
- Add_Action (Table.States (712), 96, 897);
- Table.States (712).Kernel := To_Vector (((111, 65, 1, False),
(111, 65, 0, False), (223, 65, 1, False)));
- Table.States (712).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 111, 1)));
+ Add_Goto (Table.States (709), 322, 146);
+ Add_Goto (Table.States (709), 331, 147);
+ Table.States (709).Kernel := To_Vector ((0 => (327, 20, 0,
False)));
+ Table.States (709).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (710).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (710), (74, 97), (229, 8), 1, null, null);
+ Table.States (710).Kernel := To_Vector ((0 => (229, 34, 0,
False)));
+ Table.States (710).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 229, 1)));
+ Table.States (711).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (711), 34, 889);
+ Add_Action (Table.States (711), 39, Reduce, (110, 3), 1, null,
null);
+ Add_Conflict (Table.States (711), 39, (111, 1), 1, null, null);
+ Add_Action (Table.States (711), 41, Reduce, (112, 4), 1, null,
null);
+ Add_Action (Table.States (711), 49, Reduce, (112, 4), 1, null,
null);
+ Add_Action (Table.States (711), 54, Reduce, (112, 4), 1, null,
null);
+ Table.States (711).Kernel := To_Vector (((110, 36, 0, False),
(111, 36, 0, False), (112, 36, 0, False),
+ (229, 36, 3, False), (229, 36, 1, False)));
+ Table.States (711).Minimal_Complete_Actions := To_Vector
(((Reduce, 110, 1), (Reduce, 111, 1), (Reduce,
+ 112, 1)));
+ Table.States (712).Action_List.Set_Capacity (15);
+ Add_Action (Table.States (712), 3, 122);
+ Add_Action (Table.States (712), 39, 123);
+ Add_Action (Table.States (712), 40, 124);
+ Add_Action (Table.States (712), 41, 125);
+ Add_Action (Table.States (712), 52, 126);
+ Add_Action (Table.States (712), 74, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (712), 76, 127);
+ Add_Action (Table.States (712), 79, 31);
+ Add_Action (Table.States (712), 95, 128);
+ Add_Action (Table.States (712), 96, 129);
+ Add_Action (Table.States (712), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (712), 104, 130);
+ Add_Action (Table.States (712), 105, 120);
+ Add_Action (Table.States (712), 106, 34);
+ Add_Action (Table.States (712), 107, 35);
+ Table.States (712).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (712), 118, 131);
+ Add_Goto (Table.States (712), 129, 42);
+ Add_Goto (Table.States (712), 192, 132);
+ Add_Goto (Table.States (712), 193, 890);
+ Add_Goto (Table.States (712), 198, 134);
+ Add_Goto (Table.States (712), 240, 135);
+ Add_Goto (Table.States (712), 259, 136);
+ Add_Goto (Table.States (712), 273, 93);
+ Add_Goto (Table.States (712), 276, 137);
+ Add_Goto (Table.States (712), 283, 138);
+ Add_Goto (Table.States (712), 284, 139);
+ Add_Goto (Table.States (712), 285, 140);
+ Add_Goto (Table.States (712), 286, 141);
+ Add_Goto (Table.States (712), 287, 142);
+ Add_Goto (Table.States (712), 288, 143);
+ Add_Goto (Table.States (712), 294, 98);
+ Add_Goto (Table.States (712), 302, 144);
+ Add_Goto (Table.States (712), 321, 145);
+ Add_Goto (Table.States (712), 322, 146);
+ Add_Goto (Table.States (712), 331, 147);
+ Table.States (712).Kernel := To_Vector ((0 => (327, 38, 0,
False)));
+ Table.States (712).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
Table.States (713).Action_List.Set_Capacity (1);
- Add_Action (Table.States (713), 34, 898);
- Table.States (713).Kernel := To_Vector (((228, 66, 3, False),
(228, 66, 1, False)));
- Table.States (713).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 34, 898)));
- Table.States (714).Action_List.Set_Capacity (2);
- Add_Action (Table.States (714), 104, 899);
- Add_Action (Table.States (714), 106, 900);
- Table.States (714).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (714), 180, 901);
- Add_Goto (Table.States (714), 181, 902);
- Table.States (714).Kernel := To_Vector ((0 => (183, 76, 2,
False)));
- Table.States (714).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 899)));
- Table.States (715).Action_List.Set_Capacity (1);
- Add_Action (Table.States (715), 39, 903);
- Table.States (715).Kernel := To_Vector ((0 => (259, 109, 5,
False)));
- Table.States (715).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 39, 903)));
- Table.States (716).Action_List.Set_Capacity (1);
- Add_Action (Table.States (716), 39, 904);
- Table.States (716).Kernel := To_Vector (((162, 110, 5, False),
(162, 110, 2, False)));
- Table.States (716).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 39, 904)));
- Table.States (717).Action_List.Set_Capacity (3);
- Add_Action (Table.States (717), 41, 707);
- Add_Action (Table.States (717), 49, 905);
- Add_Action (Table.States (717), 54, 710);
- Table.States (717).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (717), 280, 906);
- Table.States (717).Kernel := To_Vector (((260, 111, 2, False),
(326, 111, 2, False)));
- Table.States (717).Minimal_Complete_Actions := To_Vector (((Shift,
49, 905), (Shift, 41, 707)));
- Table.States (718).Action_List.Set_Capacity (2);
- Add_Action (Table.States (718), (74, 96), (326, 8), 1, null, null);
- Table.States (718).Kernel := To_Vector ((0 => (326, 114, 0,
False)));
- Table.States (718).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 326, 1)));
- Table.States (719).Action_List.Set_Capacity (2);
- Add_Action (Table.States (719), (74, 96), (326, 6), 1, null, null);
- Table.States (719).Kernel := To_Vector ((0 => (326, 120, 0,
False)));
- Table.States (719).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 326, 1)));
+ Add_Action (Table.States (713), 54, 891);
+ Table.States (713).Kernel := To_Vector ((0 => (281, 41, 1,
False)));
+ Table.States (713).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 54, 891)));
+ Table.States (714).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (714), 34, 892);
+ Table.States (714).Kernel := To_Vector (((229, 51, 3, False),
(229, 51, 1, False)));
+ Table.States (714).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 34, 892)));
+ Table.States (715).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (715), 3, 122);
+ Add_Action (Table.States (715), 39, 123);
+ Add_Action (Table.States (715), 40, 124);
+ Add_Action (Table.States (715), 41, 125);
+ Add_Action (Table.States (715), 76, 127);
+ Add_Action (Table.States (715), 79, 31);
+ Add_Action (Table.States (715), 95, 128);
+ Add_Action (Table.States (715), 96, 129);
+ Add_Action (Table.States (715), 104, 130);
+ Add_Action (Table.States (715), 105, 120);
+ Add_Action (Table.States (715), 106, 34);
+ Add_Action (Table.States (715), 107, 35);
+ Table.States (715).Goto_List.Set_Capacity (11);
+ Add_Goto (Table.States (715), 118, 131);
+ Add_Goto (Table.States (715), 129, 42);
+ Add_Goto (Table.States (715), 198, 134);
+ Add_Goto (Table.States (715), 240, 135);
+ Add_Goto (Table.States (715), 259, 136);
+ Add_Goto (Table.States (715), 273, 93);
+ Add_Goto (Table.States (715), 294, 98);
+ Add_Goto (Table.States (715), 302, 893);
+ Add_Goto (Table.States (715), 321, 145);
+ Add_Goto (Table.States (715), 322, 146);
+ Add_Goto (Table.States (715), 331, 147);
+ Table.States (715).Kernel := To_Vector ((0 => (327, 53, 3,
False)));
+ Table.States (715).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
+ Table.States (716).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (716), 15, 894);
+ Add_Action (Table.States (716), 24, Reduce, (151, 1), 0, null,
null);
+ Add_Action (Table.States (716), 28, 184);
+ Add_Action (Table.States (716), 41, 895);
+ Add_Action (Table.States (716), 105, 165);
+ Table.States (716).Goto_List.Set_Capacity (10);
+ Add_Goto (Table.States (716), 122, 896);
+ Add_Goto (Table.States (716), 128, 41);
+ Add_Goto (Table.States (716), 147, 897);
+ Add_Goto (Table.States (716), 149, 898);
+ Add_Goto (Table.States (716), 150, 899);
+ Add_Goto (Table.States (716), 151, 900);
+ Add_Goto (Table.States (716), 183, 56);
+ Add_Goto (Table.States (716), 220, 901);
+ Add_Goto (Table.States (716), 282, 95);
+ Add_Goto (Table.States (716), 328, 902);
+ Table.States (716).Kernel := To_Vector ((0 => (281, 54, 2,
False)));
+ Table.States (716).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 151, 0)));
+ Table.States (717).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (717), 34, 903);
+ Add_Action (Table.States (717), 39, Reduce, (110, 4), 1, null,
null);
+ Table.States (717).Kernel := To_Vector (((110, 64, 0, False),
(229, 64, 3, False), (229, 64, 1, False)));
+ Table.States (717).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 110, 1)));
+ Table.States (718).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (718), 36, 904);
+ Add_Action (Table.States (718), 41, Reduce, (112, 3), 1, null,
null);
+ Add_Action (Table.States (718), 49, Reduce, (112, 3), 1, null,
null);
+ Add_Action (Table.States (718), 54, Reduce, (112, 3), 1, null,
null);
+ Add_Action (Table.States (718), 97, 905);
+ Table.States (718).Kernel := To_Vector (((112, 65, 1, False),
(112, 65, 0, False), (224, 65, 1, False)));
+ Table.States (718).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 112, 1)));
+ Table.States (719).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (719), 34, 906);
+ Table.States (719).Kernel := To_Vector (((229, 66, 3, False),
(229, 66, 1, False)));
+ Table.States (719).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 34, 906)));
Table.States (720).Action_List.Set_Capacity (2);
- Add_Action (Table.States (720), (74, 96), (326, 9), 1, null, null);
- Table.States (720).Kernel := To_Vector ((0 => (326, 162, 0,
False)));
- Table.States (720).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 326, 1)));
- Table.States (721).Action_List.Set_Capacity (2);
- Add_Action (Table.States (721), (74, 96), (326, 0), 1, null, null);
- Table.States (721).Kernel := To_Vector ((0 => (326, 183, 0,
False)));
- Table.States (721).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 326, 1)));
- Table.States (722).Action_List.Set_Capacity (2);
- Add_Action (Table.States (722), (74, 96), (326, 10), 1, null,
null);
- Table.States (722).Kernel := To_Vector ((0 => (326, 228, 0,
False)));
- Table.States (722).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 326, 1)));
- Table.States (723).Action_List.Set_Capacity (1);
- Add_Action (Table.States (723), 7, 556);
- Table.States (723).Kernel := To_Vector (((114, 241, 2, False),
(114, 241, 3, True), (114, 241, 2, False)));
- Table.States (723).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 7, 556)));
+ Add_Action (Table.States (720), 105, 907);
+ Add_Action (Table.States (720), 107, 908);
+ Table.States (720).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (720), 181, 909);
+ Add_Goto (Table.States (720), 182, 910);
+ Table.States (720).Kernel := To_Vector ((0 => (184, 76, 2,
False)));
+ Table.States (720).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 907)));
+ Table.States (721).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (721), 39, 911);
+ Table.States (721).Kernel := To_Vector ((0 => (260, 110, 5,
False)));
+ Table.States (721).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 39, 911)));
+ Table.States (722).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (722), 39, 912);
+ Table.States (722).Kernel := To_Vector (((163, 111, 5, False),
(163, 111, 2, False)));
+ Table.States (722).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 39, 912)));
+ Table.States (723).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (723), 41, 713);
+ Add_Action (Table.States (723), 49, 913);
+ Add_Action (Table.States (723), 54, 716);
+ Table.States (723).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (723), 281, 914);
+ Table.States (723).Kernel := To_Vector (((261, 112, 2, False),
(327, 112, 2, False)));
+ Table.States (723).Minimal_Complete_Actions := To_Vector (((Shift,
49, 913), (Shift, 41, 713)));
Table.States (724).Action_List.Set_Capacity (2);
- Add_Action (Table.States (724), 74, 337);
- Add_Action (Table.States (724), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (724).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (724), 122, 907);
- Table.States (724).Kernel := To_Vector ((0 => (206, 326, 1,
False)));
- Table.States (724).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (725).Action_List.Set_Capacity (40);
- Add_Action (Table.States (725), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (331, 0), 5,
- use_clause_0'Access, null);
- Table.States (725).Kernel := To_Vector ((0 => (331, 96, 0,
False)));
- Table.States (725).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 331, 5)));
- Table.States (726).Action_List.Set_Capacity (6);
- Add_Action (Table.States (726), 74, 337);
- Add_Action (Table.States (726), 76, 235);
- Add_Action (Table.States (726), 84, 237);
- Add_Action (Table.States (726), 96, Reduce, (122, 1), 0, null,
null);
- Add_Action (Table.States (726), 101, 239);
- Add_Action (Table.States (726), 102, 240);
- Table.States (726).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (726), 115, 241);
- Add_Goto (Table.States (726), 122, 908);
- Add_Goto (Table.States (726), 322, 242);
- Table.States (726).Kernel := To_Vector (((128, 239, 2, True),
(239, 239, 5, True), (239, 239, 2, True),
- (245, 239, 1, False), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (726).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (727).Action_List.Set_Capacity (6);
- Add_Action (Table.States (727), 74, 337);
- Add_Action (Table.States (727), 76, 235);
- Add_Action (Table.States (727), 84, 237);
- Add_Action (Table.States (727), 96, Reduce, (122, 1), 0, null,
null);
- Add_Action (Table.States (727), 101, 239);
- Add_Action (Table.States (727), 102, 240);
- Table.States (727).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (727), 115, 241);
- Add_Goto (Table.States (727), 122, 909);
- Add_Goto (Table.States (727), 322, 242);
- Table.States (727).Kernel := To_Vector (((128, 239, 2, True),
(239, 239, 5, True), (239, 239, 2, True),
- (245, 239, 1, False), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (727).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (728).Action_List.Set_Capacity (3);
- Add_Action (Table.States (728), (104, 105, 106), (208, 0), 1,
null, null);
- Table.States (728).Kernel := To_Vector ((0 => (208, 9, 0, False)));
- Table.States (728).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 208, 1)));
- Table.States (729).Action_List.Set_Capacity (3);
- Add_Action (Table.States (729), (104, 105, 106), (208, 1), 1,
null, null);
- Table.States (729).Kernel := To_Vector ((0 => (208, 16, 0,
False)));
- Table.States (729).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 208, 1)));
+ Add_Action (Table.States (724), (74, 97), (327, 8), 1, null, null);
+ Table.States (724).Kernel := To_Vector ((0 => (327, 115, 0,
False)));
+ Table.States (724).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 327, 1)));
+ Table.States (725).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (725), (74, 97), (327, 6), 1, null, null);
+ Table.States (725).Kernel := To_Vector ((0 => (327, 121, 0,
False)));
+ Table.States (725).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 327, 1)));
+ Table.States (726).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (726), (74, 97), (327, 9), 1, null, null);
+ Table.States (726).Kernel := To_Vector ((0 => (327, 163, 0,
False)));
+ Table.States (726).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 327, 1)));
+ Table.States (727).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (727), (74, 97), (327, 0), 1, null, null);
+ Table.States (727).Kernel := To_Vector ((0 => (327, 184, 0,
False)));
+ Table.States (727).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 327, 1)));
+ Table.States (728).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (728), (74, 97), (327, 10), 1, null,
null);
+ Table.States (728).Kernel := To_Vector ((0 => (327, 229, 0,
False)));
+ Table.States (728).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 327, 1)));
+ Table.States (729).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (729), 7, 560);
+ Table.States (729).Kernel := To_Vector (((115, 242, 2, False),
(115, 242, 3, True), (115, 242, 2, False)));
+ Table.States (729).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 7, 560)));
Table.States (730).Action_List.Set_Capacity (2);
- Add_Action (Table.States (730), (29, 50), (270, 0), 1, null, null);
- Table.States (730).Kernel := To_Vector ((0 => (270, 51, 0,
False)));
- Table.States (730).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 270, 1)));
- Table.States (731).Action_List.Set_Capacity (3);
- Add_Action (Table.States (731), 104, 119);
- Add_Action (Table.States (731), 105, 33);
- Add_Action (Table.States (731), 106, 34);
- Table.States (731).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (731), 128, 41);
- Add_Goto (Table.States (731), 239, 910);
- Add_Goto (Table.States (731), 272, 92);
- Add_Goto (Table.States (731), 293, 97);
- Table.States (731).Kernel := To_Vector ((0 => (114, 208, 1,
False)));
- Table.States (731).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (732).Action_List.Set_Capacity (2);
- Add_Action (Table.States (732), 29, 911);
- Add_Action (Table.States (732), 50, 912);
- Table.States (732).Kernel := To_Vector (((114, 270, 1, False),
(114, 270, 2, True)));
- Table.States (732).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 50, 912)));
- Table.States (732).Minimal_Complete_Actions_Recursive := True;
- Table.States (733).Action_List.Set_Capacity (3);
- Add_Action (Table.States (733), 104, 119);
- Add_Action (Table.States (733), 105, 33);
- Add_Action (Table.States (733), 106, 34);
- Table.States (733).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (733), 128, 41);
- Add_Goto (Table.States (733), 239, 913);
- Add_Goto (Table.States (733), 272, 92);
- Add_Goto (Table.States (733), 293, 97);
- Table.States (733).Kernel := To_Vector ((0 => (245, 56, 2,
False)));
- Table.States (733).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (734).Action_List.Set_Capacity (1);
- Add_Action (Table.States (734), 96, 914);
- Table.States (734).Kernel := To_Vector ((0 => (133, 220, 1,
False)));
- Table.States (734).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 914)));
+ Add_Action (Table.States (730), 74, 338);
+ Add_Action (Table.States (730), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (730).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (730), 123, 915);
+ Table.States (730).Kernel := To_Vector ((0 => (207, 327, 1,
False)));
+ Table.States (730).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (731).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (731), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (332, 0), 5,
+ use_clause_0'Access, null);
+ Table.States (731).Kernel := To_Vector ((0 => (332, 97, 0,
False)));
+ Table.States (731).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 332, 5)));
+ Table.States (732).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (732), 74, 338);
+ Add_Action (Table.States (732), 76, 236);
+ Add_Action (Table.States (732), 85, 238);
+ Add_Action (Table.States (732), 97, Reduce, (123, 1), 0, null,
null);
+ Add_Action (Table.States (732), 102, 240);
+ Add_Action (Table.States (732), 103, 241);
+ Table.States (732).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (732), 116, 242);
+ Add_Goto (Table.States (732), 123, 916);
+ Add_Goto (Table.States (732), 323, 243);
+ Table.States (732).Kernel := To_Vector (((129, 240, 2, True),
(240, 240, 5, True), (240, 240, 2, True),
+ (246, 240, 1, False), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (732).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (733).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (733), 74, 338);
+ Add_Action (Table.States (733), 76, 236);
+ Add_Action (Table.States (733), 85, 238);
+ Add_Action (Table.States (733), 97, Reduce, (123, 1), 0, null,
null);
+ Add_Action (Table.States (733), 102, 240);
+ Add_Action (Table.States (733), 103, 241);
+ Table.States (733).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (733), 116, 242);
+ Add_Goto (Table.States (733), 123, 917);
+ Add_Goto (Table.States (733), 323, 243);
+ Table.States (733).Kernel := To_Vector (((129, 240, 2, True),
(240, 240, 5, True), (240, 240, 2, True),
+ (246, 240, 1, False), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (733).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (734).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (734), (79, 105, 106, 107), (209, 0), 1,
null, null);
+ Table.States (734).Kernel := To_Vector ((0 => (209, 9, 0, False)));
+ Table.States (734).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 209, 1)));
Table.States (735).Action_List.Set_Capacity (4);
- Add_Action (Table.States (735), 44, 915);
- Add_Action (Table.States (735), 104, 916);
- Add_Action (Table.States (735), 105, 33);
- Add_Action (Table.States (735), 106, 34);
- Table.States (735).Goto_List.Set_Capacity (6);
- Add_Goto (Table.States (735), 128, 41);
- Add_Goto (Table.States (735), 184, 917);
- Add_Goto (Table.States (735), 185, 918);
- Add_Goto (Table.States (735), 239, 919);
- Add_Goto (Table.States (735), 272, 92);
- Add_Goto (Table.States (735), 293, 97);
- Table.States (735).Kernel := To_Vector (((187, 72, 4, False),
(187, 72, 2, False)));
- Table.States (735).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 916)));
+ Add_Action (Table.States (735), (79, 105, 106, 107), (209, 1), 1,
null, null);
+ Table.States (735).Kernel := To_Vector ((0 => (209, 16, 0,
False)));
+ Table.States (735).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 209, 1)));
Table.States (736).Action_List.Set_Capacity (2);
- Add_Action (Table.States (736), (24, 72), (188, 1), 1, null, null);
- Table.States (736).Kernel := To_Vector ((0 => (188, 187, 0,
False)));
- Table.States (736).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 188, 1)));
- Table.States (737).Action_List.Set_Capacity (2);
- Add_Action (Table.States (737), 24, Reduce, (189, 0), 1, null,
null);
- Add_Action (Table.States (737), 72, 735);
- Table.States (737).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (737), 187, 920);
- Table.States (737).Kernel := To_Vector (((188, 188, 3, True),
(189, 188, 0, False)));
- Table.States (737).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 189, 1)));
- Table.States (738).Action_List.Set_Capacity (1);
- Add_Action (Table.States (738), (1 => 24), (218, 0), 3,
handled_sequence_of_statements_0'Access, null);
- Table.States (738).Kernel := To_Vector ((0 => (218, 189, 0,
False)));
- Table.States (738).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 218, 3)));
- Table.States (739).Action_List.Set_Capacity (2);
- Add_Action (Table.States (739), (24, 72), (188, 2), 1, null, null);
- Table.States (739).Kernel := To_Vector ((0 => (188, 257, 0,
False)));
- Table.States (739).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 188, 1)));
+ Add_Action (Table.States (736), (29, 50), (271, 0), 1, null, null);
+ Table.States (736).Kernel := To_Vector ((0 => (271, 51, 0,
False)));
+ Table.States (736).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 271, 1)));
+ Table.States (737).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (737), 79, 31);
+ Add_Action (Table.States (737), 105, 120);
+ Add_Action (Table.States (737), 106, 34);
+ Add_Action (Table.States (737), 107, 35);
+ Table.States (737).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (737), 129, 42);
+ Add_Goto (Table.States (737), 240, 918);
+ Add_Goto (Table.States (737), 273, 93);
+ Add_Goto (Table.States (737), 294, 98);
+ Table.States (737).Kernel := To_Vector ((0 => (115, 209, 1,
False)));
+ Table.States (737).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (738).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (738), 29, 919);
+ Add_Action (Table.States (738), 50, 920);
+ Table.States (738).Kernel := To_Vector (((115, 271, 1, False),
(115, 271, 2, True)));
+ Table.States (738).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 50, 920)));
+ Table.States (738).Minimal_Complete_Actions_Recursive := True;
+ Table.States (739).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (739), 79, 31);
+ Add_Action (Table.States (739), 105, 120);
+ Add_Action (Table.States (739), 106, 34);
+ Add_Action (Table.States (739), 107, 35);
+ Table.States (739).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (739), 129, 42);
+ Add_Goto (Table.States (739), 240, 921);
+ Add_Goto (Table.States (739), 273, 93);
+ Add_Goto (Table.States (739), 294, 98);
+ Table.States (739).Kernel := To_Vector ((0 => (246, 56, 2,
False)));
+ Table.States (739).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
Table.States (740).Action_List.Set_Capacity (1);
- Add_Action (Table.States (740), 24, 921);
- Table.States (740).Kernel := To_Vector ((0 => (133, 218, 2,
False)));
- Table.States (740).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 921)));
- end Subr_13;
- procedure Subr_14
- is begin
- Table.States (741).Action_List.Set_Capacity (2);
- Add_Action (Table.States (741), 96, Reduce, (220, 1), 0, null,
null);
- Add_Action (Table.States (741), 104, 149);
- Table.States (741).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (741), 220, 922);
- Table.States (741).Kernel := To_Vector ((0 => (232, 37, 1,
False)));
- Table.States (741).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 220, 0)));
- Table.States (742).Action_List.Set_Capacity (1);
- Add_Action (Table.States (742), 37, 923);
- Table.States (742).Kernel := To_Vector ((0 => (232, 24, 2,
False)));
- Table.States (742).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 37, 923)));
- Table.States (743).Action_List.Set_Capacity (1);
- Add_Action (Table.States (743), 96, 924);
- Table.States (743).Kernel := To_Vector ((0 => (157, 192, 1,
False)));
- Table.States (743).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 924)));
+ Add_Action (Table.States (740), 97, 922);
+ Table.States (740).Kernel := To_Vector ((0 => (134, 221, 1,
False)));
+ Table.States (740).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 922)));
+ Table.States (741).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (741), 44, 923);
+ Add_Action (Table.States (741), 79, 31);
+ Add_Action (Table.States (741), 105, 924);
+ Add_Action (Table.States (741), 106, 34);
+ Add_Action (Table.States (741), 107, 35);
+ Table.States (741).Goto_List.Set_Capacity (6);
+ Add_Goto (Table.States (741), 129, 42);
+ Add_Goto (Table.States (741), 185, 925);
+ Add_Goto (Table.States (741), 186, 926);
+ Add_Goto (Table.States (741), 240, 927);
+ Add_Goto (Table.States (741), 273, 93);
+ Add_Goto (Table.States (741), 294, 98);
+ Table.States (741).Kernel := To_Vector (((188, 72, 4, False),
(188, 72, 2, False)));
+ Table.States (741).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 924)));
+ Table.States (742).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (742), (24, 72), (189, 1), 1, null, null);
+ Table.States (742).Kernel := To_Vector ((0 => (189, 188, 0,
False)));
+ Table.States (742).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 189, 1)));
+ Table.States (743).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (743), 24, Reduce, (190, 0), 1, null,
null);
+ Add_Action (Table.States (743), 72, 741);
+ Table.States (743).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (743), 188, 928);
+ Table.States (743).Kernel := To_Vector (((189, 189, 3, True),
(190, 189, 0, False)));
+ Table.States (743).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 190, 1)));
Table.States (744).Action_List.Set_Capacity (1);
- Add_Action (Table.States (744), 41, 925);
- Table.States (744).Kernel := To_Vector (((241, 40, 1, False),
(314, 40, 6, False), (314, 40, 2, False)));
- Table.States (744).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 41, 925)));
- Table.States (745).Action_List.Set_Capacity (3);
- Add_Action (Table.States (745), 74, 337);
- Add_Action (Table.States (745), 82, 926);
- Add_Action (Table.States (745), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (745).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (745), 122, 927);
- Table.States (745).Kernel := To_Vector (((244, 114, 2, False),
(244, 114, 1, False)));
- Table.States (745).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (746).Action_List.Set_Capacity (3);
- Add_Action (Table.States (746), 74, 337);
- Add_Action (Table.States (746), 82, 928);
- Add_Action (Table.States (746), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (746).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (746), 122, 929);
- Table.States (746).Kernel := To_Vector (((244, 120, 2, False),
(244, 120, 1, False)));
- Table.States (746).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (747).Action_List.Set_Capacity (3);
- Add_Action (Table.States (747), 74, 337);
- Add_Action (Table.States (747), 82, 930);
- Add_Action (Table.States (747), 96, Reduce, (122, 1), 0, null,
null);
+ Add_Action (Table.States (744), (1 => 24), (219, 0), 3,
handled_sequence_of_statements_0'Access, null);
+ Table.States (744).Kernel := To_Vector ((0 => (219, 190, 0,
False)));
+ Table.States (744).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 219, 3)));
+ Table.States (745).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (745), (24, 72), (189, 2), 1, null, null);
+ Table.States (745).Kernel := To_Vector ((0 => (189, 258, 0,
False)));
+ Table.States (745).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 189, 1)));
+ Table.States (746).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (746), 24, 929);
+ Table.States (746).Kernel := To_Vector ((0 => (134, 219, 2,
False)));
+ Table.States (746).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 929)));
+ Table.States (747).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (747), 97, Reduce, (221, 1), 0, null,
null);
+ Add_Action (Table.States (747), 105, 150);
Table.States (747).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (747), 122, 931);
- Table.States (747).Kernel := To_Vector (((244, 314, 2, False),
(244, 314, 1, False)));
- Table.States (747).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (748).Action_List.Set_Capacity (2);
- Add_Action (Table.States (748), (77, 83), (278, 0), 3, null, null);
- Table.States (748).Kernel := To_Vector ((0 => (278, 277, 0,
True)));
- Table.States (748).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 278, 3)));
- Table.States (748).Minimal_Complete_Actions_Recursive := True;
+ Add_Goto (Table.States (747), 221, 930);
+ Table.States (747).Kernel := To_Vector ((0 => (233, 37, 1,
False)));
+ Table.States (747).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 221, 0)));
+ Table.States (748).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (748), 37, 931);
+ Table.States (748).Kernel := To_Vector ((0 => (233, 24, 2,
False)));
+ Table.States (748).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 37, 931)));
Table.States (749).Action_List.Set_Capacity (1);
- Add_Action (Table.States (749), 77, 932);
- Table.States (749).Kernel := To_Vector ((0 => (129, 191, 1,
False)));
- Table.States (749).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 932)));
+ Add_Action (Table.States (749), 97, 932);
+ Table.States (749).Kernel := To_Vector ((0 => (158, 193, 1,
False)));
+ Table.States (749).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 932)));
Table.States (750).Action_List.Set_Capacity (1);
- Add_Action (Table.States (750), 77, 933);
- Table.States (750).Kernel := To_Vector ((0 => (179, 167, 2,
False)));
- Table.States (750).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 933)));
- Table.States (751).Action_List.Set_Capacity (1);
- Add_Action (Table.States (751), 96, 934);
- Table.States (751).Kernel := To_Vector ((0 => (179, 122, 1,
False)));
- Table.States (751).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 934)));
+ Add_Action (Table.States (750), 41, 933);
+ Table.States (750).Kernel := To_Vector (((242, 40, 1, False),
(315, 40, 6, False), (315, 40, 2, False)));
+ Table.States (750).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 41, 933)));
+ Table.States (751).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (751), 74, 338);
+ Add_Action (Table.States (751), 83, 934);
+ Add_Action (Table.States (751), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (751).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (751), 123, 935);
+ Table.States (751).Kernel := To_Vector (((245, 115, 2, False),
(245, 115, 1, False)));
+ Table.States (751).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
Table.States (752).Action_List.Set_Capacity (3);
- Add_Action (Table.States (752), 104, 119);
- Add_Action (Table.States (752), 105, 33);
- Add_Action (Table.States (752), 106, 34);
- Table.States (752).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (752), 128, 41);
- Add_Goto (Table.States (752), 239, 935);
- Add_Goto (Table.States (752), 272, 92);
- Add_Goto (Table.States (752), 293, 97);
- Table.States (752).Kernel := To_Vector ((0 => (213, 39, 2,
False)));
- Table.States (752).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
+ Add_Action (Table.States (752), 74, 338);
+ Add_Action (Table.States (752), 83, 936);
+ Add_Action (Table.States (752), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (752).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (752), 123, 937);
+ Table.States (752).Kernel := To_Vector (((245, 121, 2, False),
(245, 121, 1, False)));
+ Table.States (752).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
Table.States (753).Action_List.Set_Capacity (3);
- Add_Action (Table.States (753), 104, 119);
- Add_Action (Table.States (753), 105, 33);
- Add_Action (Table.States (753), 106, 34);
- Table.States (753).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (753), 128, 41);
- Add_Goto (Table.States (753), 239, 936);
- Add_Goto (Table.States (753), 272, 92);
- Add_Goto (Table.States (753), 293, 97);
- Table.States (753).Kernel := To_Vector ((0 => (213, 39, 2,
False)));
- Table.States (753).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
+ Add_Action (Table.States (753), 74, 338);
+ Add_Action (Table.States (753), 83, 938);
+ Add_Action (Table.States (753), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (753).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (753), 123, 939);
+ Table.States (753).Kernel := To_Vector (((245, 315, 2, False),
(245, 315, 1, False)));
+ Table.States (753).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
Table.States (754).Action_List.Set_Capacity (2);
- Add_Action (Table.States (754), 74, 447);
- Add_Action (Table.States (754), 77, 937);
- Table.States (754).Kernel := To_Vector (((117, 192, 4, False),
(117, 192, 2, False), (256, 192, 1,
- False)));
- Table.States (754).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 937)));
+ Add_Action (Table.States (754), (77, 84), (279, 0), 3, null, null);
+ Table.States (754).Kernel := To_Vector ((0 => (279, 278, 0,
True)));
+ Table.States (754).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 279, 3)));
+ Table.States (754).Minimal_Complete_Actions_Recursive := True;
Table.States (755).Action_List.Set_Capacity (1);
- Add_Action (Table.States (755), 96, 938);
- Table.States (755).Kernel := To_Vector ((0 => (193, 122, 1,
False)));
- Table.States (755).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 938)));
+ Add_Action (Table.States (755), 77, 940);
+ Table.States (755).Kernel := To_Vector ((0 => (130, 192, 1,
False)));
+ Table.States (755).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 940)));
Table.States (756).Action_List.Set_Capacity (1);
- Add_Action (Table.States (756), 96, 939);
- Table.States (756).Kernel := To_Vector ((0 => (243, 122, 1,
False)));
- Table.States (756).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 939)));
+ Add_Action (Table.States (756), 77, 941);
+ Table.States (756).Kernel := To_Vector ((0 => (180, 168, 2,
False)));
+ Table.States (756).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 941)));
Table.States (757).Action_List.Set_Capacity (1);
- Add_Action (Table.States (757), 96, 940);
- Table.States (757).Kernel := To_Vector ((0 => (112, 122, 1,
False)));
- Table.States (757).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 940)));
- Table.States (758).Action_List.Set_Capacity (1);
- Add_Action (Table.States (758), 96, 941);
- Table.States (758).Kernel := To_Vector ((0 => (308, 122, 1,
False)));
- Table.States (758).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 941)));
- Table.States (759).Action_List.Set_Capacity (1);
- Add_Action (Table.States (759), 96, 942);
- Table.States (759).Kernel := To_Vector ((0 => (311, 122, 1,
False)));
- Table.States (759).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 942)));
- Table.States (760).Action_List.Set_Capacity (1);
- Add_Action (Table.States (760), 13, 943);
- Table.States (760).Kernel := To_Vector ((0 => (307, 159, 3,
False)));
- Table.States (760).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 13, 943)));
+ Add_Action (Table.States (757), 97, 942);
+ Table.States (757).Kernel := To_Vector ((0 => (180, 123, 1,
False)));
+ Table.States (757).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 942)));
+ Table.States (758).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (758), 79, 31);
+ Add_Action (Table.States (758), 105, 120);
+ Add_Action (Table.States (758), 106, 34);
+ Add_Action (Table.States (758), 107, 35);
+ Table.States (758).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (758), 129, 42);
+ Add_Goto (Table.States (758), 240, 943);
+ Add_Goto (Table.States (758), 273, 93);
+ Add_Goto (Table.States (758), 294, 98);
+ Table.States (758).Kernel := To_Vector ((0 => (214, 39, 2,
False)));
+ Table.States (758).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (759).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (759), 79, 31);
+ Add_Action (Table.States (759), 105, 120);
+ Add_Action (Table.States (759), 106, 34);
+ Add_Action (Table.States (759), 107, 35);
+ Table.States (759).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (759), 129, 42);
+ Add_Goto (Table.States (759), 240, 944);
+ Add_Goto (Table.States (759), 273, 93);
+ Add_Goto (Table.States (759), 294, 98);
+ Table.States (759).Kernel := To_Vector ((0 => (214, 39, 2,
False)));
+ Table.States (759).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (760).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (760), 74, 450);
+ Add_Action (Table.States (760), 77, 945);
+ Table.States (760).Kernel := To_Vector (((118, 193, 4, False),
(118, 193, 2, False), (257, 193, 1,
+ False)));
+ Table.States (760).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 945)));
Table.States (761).Action_List.Set_Capacity (1);
- Add_Action (Table.States (761), 24, 944);
- Table.States (761).Kernel := To_Vector ((0 => (113, 218, 2,
False)));
- Table.States (761).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 944)));
- Table.States (762).Action_List.Set_Capacity (15);
- Add_Action (Table.States (762), 3, 121);
- Add_Action (Table.States (762), 39, 122);
- Add_Action (Table.States (762), 40, 261);
- Add_Action (Table.States (762), 41, 124);
- Add_Action (Table.States (762), 44, 263);
- Add_Action (Table.States (762), 52, 125);
- Add_Action (Table.States (762), 76, 126);
- Add_Action (Table.States (762), 79, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (762), 87, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (762), 94, 127);
- Add_Action (Table.States (762), 95, 128);
- Add_Action (Table.States (762), 103, 129);
- Add_Action (Table.States (762), 104, 119);
- Add_Action (Table.States (762), 105, 33);
- Add_Action (Table.States (762), 106, 34);
- Table.States (762).Goto_List.Set_Capacity (22);
- Add_Goto (Table.States (762), 117, 130);
- Add_Goto (Table.States (762), 128, 41);
- Add_Goto (Table.States (762), 165, 269);
- Add_Goto (Table.States (762), 166, 945);
- Add_Goto (Table.States (762), 191, 601);
- Add_Goto (Table.States (762), 197, 133);
- Add_Goto (Table.States (762), 239, 274);
- Add_Goto (Table.States (762), 258, 135);
- Add_Goto (Table.States (762), 272, 92);
- Add_Goto (Table.States (762), 275, 136);
- Add_Goto (Table.States (762), 277, 276);
- Add_Goto (Table.States (762), 282, 137);
- Add_Goto (Table.States (762), 283, 138);
- Add_Goto (Table.States (762), 284, 139);
- Add_Goto (Table.States (762), 285, 140);
- Add_Goto (Table.States (762), 286, 141);
- Add_Goto (Table.States (762), 287, 142);
- Add_Goto (Table.States (762), 293, 97);
- Add_Goto (Table.States (762), 301, 277);
- Add_Goto (Table.States (762), 320, 144);
- Add_Goto (Table.States (762), 321, 145);
- Add_Goto (Table.States (762), 330, 146);
- Table.States (762).Kernel := To_Vector ((0 => (137, 72, 1,
False)));
- Table.States (762).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 166, 0)));
- Table.States (763).Action_List.Set_Capacity (2);
- Add_Action (Table.States (763), (77, 83), (138, 1), 1, null, null);
- Table.States (763).Kernel := To_Vector ((0 => (138, 137, 0,
False)));
- Table.States (763).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 138, 1)));
- Table.States (764).Action_List.Set_Capacity (2);
- Add_Action (Table.States (764), 77, Reduce, (136, 0), 4,
case_expression_0'Access, null);
- Add_Action (Table.States (764), 83, 946);
- Table.States (764).Kernel := To_Vector (((136, 138, 0, False),
(138, 138, 3, True)));
- Table.States (764).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 136, 4)));
- Table.States (765).Action_List.Set_Capacity (13);
- Add_Action (Table.States (765), 3, 121);
- Add_Action (Table.States (765), 39, 122);
- Add_Action (Table.States (765), 40, 123);
- Add_Action (Table.States (765), 41, 124);
- Add_Action (Table.States (765), 52, 125);
- Add_Action (Table.States (765), 76, 126);
- Add_Action (Table.States (765), 77, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (765), 94, 127);
- Add_Action (Table.States (765), 95, 128);
- Add_Action (Table.States (765), 103, 129);
- Add_Action (Table.States (765), 104, 119);
- Add_Action (Table.States (765), 105, 33);
- Add_Action (Table.States (765), 106, 34);
- Table.States (765).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (765), 117, 130);
- Add_Goto (Table.States (765), 128, 41);
- Add_Goto (Table.States (765), 191, 131);
- Add_Goto (Table.States (765), 192, 947);
- Add_Goto (Table.States (765), 197, 133);
- Add_Goto (Table.States (765), 239, 134);
- Add_Goto (Table.States (765), 258, 135);
- Add_Goto (Table.States (765), 272, 92);
- Add_Goto (Table.States (765), 275, 136);
- Add_Goto (Table.States (765), 282, 137);
- Add_Goto (Table.States (765), 283, 138);
- Add_Goto (Table.States (765), 284, 139);
- Add_Goto (Table.States (765), 285, 140);
- Add_Goto (Table.States (765), 286, 141);
- Add_Goto (Table.States (765), 287, 142);
- Add_Goto (Table.States (765), 293, 97);
- Add_Goto (Table.States (765), 301, 143);
- Add_Goto (Table.States (765), 320, 144);
- Add_Goto (Table.States (765), 321, 145);
- Add_Goto (Table.States (765), 330, 146);
- Table.States (765).Kernel := To_Vector ((0 => (273, 87, 0,
False)));
- Table.States (765).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (766).Action_List.Set_Capacity (3);
- Add_Action (Table.States (766), 22, 948);
- Add_Action (Table.States (766), 23, 949);
- Add_Action (Table.States (766), 77, Reduce, (221, 3), 4,
if_expression_3'Access, null);
- Table.States (766).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (766), 172, 950);
- Add_Goto (Table.States (766), 173, 951);
- Table.States (766).Kernel := To_Vector (((221, 192, 3, False),
(221, 192, 1, False), (221, 192, 2, False),
- (221, 192, 0, False)));
- Table.States (766).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 221, 4)));
+ Add_Action (Table.States (761), 97, 946);
+ Table.States (761).Kernel := To_Vector ((0 => (194, 123, 1,
False)));
+ Table.States (761).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 946)));
+ Table.States (762).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (762), 97, 947);
+ Table.States (762).Kernel := To_Vector ((0 => (244, 123, 1,
False)));
+ Table.States (762).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 947)));
+ Table.States (763).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (763), 97, 948);
+ Table.States (763).Kernel := To_Vector ((0 => (113, 123, 1,
False)));
+ Table.States (763).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 948)));
+ Table.States (764).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (764), 97, 949);
+ Table.States (764).Kernel := To_Vector ((0 => (309, 123, 1,
False)));
+ Table.States (764).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 949)));
+ Table.States (765).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (765), 97, 950);
+ Table.States (765).Kernel := To_Vector ((0 => (312, 123, 1,
False)));
+ Table.States (765).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 950)));
+ Table.States (766).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (766), 13, 951);
+ Table.States (766).Kernel := To_Vector ((0 => (308, 160, 3,
False)));
+ Table.States (766).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 13, 951)));
Table.States (767).Action_List.Set_Capacity (1);
- Add_Action (Table.States (767), 77, 952);
- Table.States (767).Kernel := To_Vector ((0 => (117, 54, 1,
False)));
- Table.States (767).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 952)));
- Table.States (768).Action_List.Set_Capacity (63);
- Add_Action (Table.States (768), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
- 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
- 88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104,
105, 106), (117, 1), 5, aggregate_1'Access,
- null);
- Table.States (768).Kernel := To_Vector ((0 => (117, 77, 0,
False)));
- Table.States (768).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 117, 5)));
- Table.States (769).Action_List.Set_Capacity (13);
- Add_Action (Table.States (769), 3, 121);
- Add_Action (Table.States (769), 39, 122);
- Add_Action (Table.States (769), 40, 123);
- Add_Action (Table.States (769), 41, 124);
- Add_Action (Table.States (769), 52, 125);
- Add_Action (Table.States (769), 76, 126);
- Add_Action (Table.States (769), 77, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (769), 94, 127);
- Add_Action (Table.States (769), 95, 128);
- Add_Action (Table.States (769), 103, 129);
- Add_Action (Table.States (769), 104, 119);
- Add_Action (Table.States (769), 105, 33);
- Add_Action (Table.States (769), 106, 34);
- Table.States (769).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (769), 117, 130);
- Add_Goto (Table.States (769), 128, 41);
- Add_Goto (Table.States (769), 191, 131);
- Add_Goto (Table.States (769), 192, 953);
- Add_Goto (Table.States (769), 197, 133);
- Add_Goto (Table.States (769), 239, 134);
- Add_Goto (Table.States (769), 258, 135);
- Add_Goto (Table.States (769), 272, 92);
- Add_Goto (Table.States (769), 275, 136);
- Add_Goto (Table.States (769), 282, 137);
- Add_Goto (Table.States (769), 283, 138);
- Add_Goto (Table.States (769), 284, 139);
- Add_Goto (Table.States (769), 285, 140);
- Add_Goto (Table.States (769), 286, 141);
- Add_Goto (Table.States (769), 287, 142);
- Add_Goto (Table.States (769), 293, 97);
- Add_Goto (Table.States (769), 301, 143);
- Add_Goto (Table.States (769), 320, 144);
- Add_Goto (Table.States (769), 321, 145);
- Add_Goto (Table.States (769), 330, 146);
- Table.States (769).Kernel := To_Vector ((0 => (277, 76, 1,
False)));
- Table.States (769).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (770).Action_List.Set_Capacity (24);
- Add_Action (Table.States (770), 4, 1);
- Add_Action (Table.States (770), 5, 2);
- Add_Action (Table.States (770), 13, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (770), 15, 3);
- Add_Action (Table.States (770), 17, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (770), 18, 4);
- Add_Action (Table.States (770), 24, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (770), 27, 5);
- Add_Action (Table.States (770), 28, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (770), 31, 9);
- Add_Action (Table.States (770), 32, 10);
- Add_Action (Table.States (770), 37, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (770), 41, 13);
- Add_Action (Table.States (770), 48, 16);
- Add_Action (Table.States (770), 52, 20);
- Add_Action (Table.States (770), 57, 21);
- Add_Action (Table.States (770), 58, 22);
- Add_Action (Table.States (770), 61, 24);
- Add_Action (Table.States (770), 72, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (770), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (770), 93, 31);
- Add_Action (Table.States (770), 104, 360);
- Add_Action (Table.States (770), 105, 33);
- Add_Action (Table.States (770), 106, 34);
- Table.States (770).Goto_List.Set_Capacity (31);
- Add_Goto (Table.States (770), 113, 36);
- Add_Goto (Table.States (770), 123, 38);
- Add_Goto (Table.States (770), 126, 39);
- Add_Goto (Table.States (770), 128, 41);
- Add_Goto (Table.States (770), 131, 42);
- Add_Goto (Table.States (770), 132, 43);
- Add_Goto (Table.States (770), 133, 44);
- Add_Goto (Table.States (770), 139, 47);
- Add_Goto (Table.States (770), 151, 50);
- Add_Goto (Table.States (770), 152, 51);
- Add_Goto (Table.States (770), 161, 53);
- Add_Goto (Table.States (770), 190, 57);
- Add_Goto (Table.States (770), 196, 59);
- Add_Goto (Table.States (770), 217, 68);
- Add_Goto (Table.States (770), 222, 70);
- Add_Goto (Table.States (770), 232, 72);
- Add_Goto (Table.States (770), 239, 73);
- Add_Goto (Table.States (770), 257, 83);
- Add_Goto (Table.States (770), 261, 86);
- Add_Goto (Table.States (770), 272, 92);
- Add_Goto (Table.States (770), 276, 93);
- Add_Goto (Table.States (770), 290, 96);
- Add_Goto (Table.States (770), 293, 97);
- Add_Goto (Table.States (770), 294, 98);
- Add_Goto (Table.States (770), 298, 99);
- Add_Goto (Table.States (770), 299, 361);
- Add_Goto (Table.States (770), 300, 954);
- Add_Goto (Table.States (770), 302, 100);
- Add_Goto (Table.States (770), 303, 101);
- Add_Goto (Table.States (770), 306, 363);
- Add_Goto (Table.States (770), 323, 114);
- Table.States (770).Kernel := To_Vector ((0 => (140, 87, 0,
False)));
- Table.States (770).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 300, 0)));
- Table.States (771).Action_List.Set_Capacity (1);
- Add_Action (Table.States (771), 96, 955);
- Table.States (771).Kernel := To_Vector ((0 => (139, 15, 1,
False)));
- Table.States (771).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 955)));
- Table.States (772).Action_List.Set_Capacity (17);
- Add_Action (Table.States (772), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 79, 83, 87, 96), (233,
+ Add_Action (Table.States (767), 24, 952);
+ Table.States (767).Kernel := To_Vector ((0 => (114, 219, 2,
False)));
+ Table.States (767).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 952)));
+ Table.States (768).Action_List.Set_Capacity (16);
+ Add_Action (Table.States (768), 3, 122);
+ Add_Action (Table.States (768), 39, 123);
+ Add_Action (Table.States (768), 40, 262);
+ Add_Action (Table.States (768), 41, 125);
+ Add_Action (Table.States (768), 44, 264);
+ Add_Action (Table.States (768), 52, 126);
+ Add_Action (Table.States (768), 76, 127);
+ Add_Action (Table.States (768), 79, 31);
+ Add_Action (Table.States (768), 80, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (768), 88, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (768), 95, 128);
+ Add_Action (Table.States (768), 96, 129);
+ Add_Action (Table.States (768), 104, 130);
+ Add_Action (Table.States (768), 105, 120);
+ Add_Action (Table.States (768), 106, 34);
+ Add_Action (Table.States (768), 107, 35);
+ Table.States (768).Goto_List.Set_Capacity (22);
+ Add_Goto (Table.States (768), 118, 131);
+ Add_Goto (Table.States (768), 129, 42);
+ Add_Goto (Table.States (768), 166, 270);
+ Add_Goto (Table.States (768), 167, 953);
+ Add_Goto (Table.States (768), 192, 606);
+ Add_Goto (Table.States (768), 198, 134);
+ Add_Goto (Table.States (768), 240, 275);
+ Add_Goto (Table.States (768), 259, 136);
+ Add_Goto (Table.States (768), 273, 93);
+ Add_Goto (Table.States (768), 276, 137);
+ Add_Goto (Table.States (768), 278, 277);
+ Add_Goto (Table.States (768), 283, 138);
+ Add_Goto (Table.States (768), 284, 139);
+ Add_Goto (Table.States (768), 285, 140);
+ Add_Goto (Table.States (768), 286, 141);
+ Add_Goto (Table.States (768), 287, 142);
+ Add_Goto (Table.States (768), 288, 143);
+ Add_Goto (Table.States (768), 294, 98);
+ Add_Goto (Table.States (768), 302, 278);
+ Add_Goto (Table.States (768), 321, 145);
+ Add_Goto (Table.States (768), 322, 146);
+ Add_Goto (Table.States (768), 331, 147);
+ Table.States (768).Kernel := To_Vector ((0 => (138, 72, 1,
False)));
+ Table.States (768).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 167, 0)));
+ Table.States (769).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (769), (77, 84), (139, 1), 1, null, null);
+ Table.States (769).Kernel := To_Vector ((0 => (139, 138, 0,
False)));
+ Table.States (769).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 139, 1)));
+ Table.States (770).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (770), 77, Reduce, (137, 0), 4,
case_expression_0'Access, null);
+ Add_Action (Table.States (770), 84, 954);
+ Table.States (770).Kernel := To_Vector (((137, 139, 0, False),
(139, 139, 3, True)));
+ Table.States (770).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 137, 4)));
+ Table.States (771).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (771), 80, 447);
+ Add_Action (Table.States (771), 88, 955);
+ Table.States (771).Kernel := To_Vector (((125, 167, 2, False),
(167, 167, 2, True)));
+ Table.States (771).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 88, 955)));
+ Table.States (772).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (772), 3, 122);
+ Add_Action (Table.States (772), 39, 123);
+ Add_Action (Table.States (772), 40, 124);
+ Add_Action (Table.States (772), 41, 125);
+ Add_Action (Table.States (772), 52, 126);
+ Add_Action (Table.States (772), 76, 127);
+ Add_Action (Table.States (772), 77, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (772), 79, 31);
+ Add_Action (Table.States (772), 95, 128);
+ Add_Action (Table.States (772), 96, 129);
+ Add_Action (Table.States (772), 104, 130);
+ Add_Action (Table.States (772), 105, 120);
+ Add_Action (Table.States (772), 106, 34);
+ Add_Action (Table.States (772), 107, 35);
+ Table.States (772).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (772), 118, 131);
+ Add_Goto (Table.States (772), 129, 42);
+ Add_Goto (Table.States (772), 192, 132);
+ Add_Goto (Table.States (772), 193, 956);
+ Add_Goto (Table.States (772), 198, 134);
+ Add_Goto (Table.States (772), 240, 135);
+ Add_Goto (Table.States (772), 259, 136);
+ Add_Goto (Table.States (772), 273, 93);
+ Add_Goto (Table.States (772), 276, 137);
+ Add_Goto (Table.States (772), 283, 138);
+ Add_Goto (Table.States (772), 284, 139);
+ Add_Goto (Table.States (772), 285, 140);
+ Add_Goto (Table.States (772), 286, 141);
+ Add_Goto (Table.States (772), 287, 142);
+ Add_Goto (Table.States (772), 288, 143);
+ Add_Goto (Table.States (772), 294, 98);
+ Add_Goto (Table.States (772), 302, 144);
+ Add_Goto (Table.States (772), 321, 145);
+ Add_Goto (Table.States (772), 322, 146);
+ Add_Goto (Table.States (772), 331, 147);
+ Table.States (772).Kernel := To_Vector ((0 => (274, 88, 0,
False)));
+ Table.States (772).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (773).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (773), 22, 957);
+ Add_Action (Table.States (773), 23, 958);
+ Add_Action (Table.States (773), 77, Reduce, (222, 3), 4,
if_expression_3'Access, null);
+ Table.States (773).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (773), 173, 959);
+ Add_Goto (Table.States (773), 174, 960);
+ Table.States (773).Kernel := To_Vector (((222, 193, 3, False),
(222, 193, 1, False), (222, 193, 2, False),
+ (222, 193, 0, False)));
+ Table.States (773).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 222, 4)));
+ Table.States (774).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (774), 77, 961);
+ Add_Action (Table.States (774), 84, 445);
+ Table.States (774).Kernel := To_Vector (((118, 126, 1, False),
(126, 126, 1, True)));
+ Table.States (774).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 961)));
+ Table.States (775).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (775), 77, 962);
+ Table.States (775).Kernel := To_Vector ((0 => (118, 54, 1,
False)));
+ Table.States (775).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 962)));
+ Table.States (776).Action_List.Set_Capacity (64);
+ Add_Action (Table.States (776), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+ 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
105, 106, 107), (118, 1), 5,
+ aggregate_1'Access, null);
+ Table.States (776).Kernel := To_Vector ((0 => (118, 77, 0,
False)));
+ Table.States (776).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 118, 5)));
+ Table.States (777).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (777), 3, 122);
+ Add_Action (Table.States (777), 39, 123);
+ Add_Action (Table.States (777), 40, 124);
+ Add_Action (Table.States (777), 41, 125);
+ Add_Action (Table.States (777), 52, 126);
+ Add_Action (Table.States (777), 76, 127);
+ Add_Action (Table.States (777), 77, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (777), 79, 31);
+ Add_Action (Table.States (777), 95, 128);
+ Add_Action (Table.States (777), 96, 129);
+ Add_Action (Table.States (777), 104, 130);
+ Add_Action (Table.States (777), 105, 120);
+ Add_Action (Table.States (777), 106, 34);
+ Add_Action (Table.States (777), 107, 35);
+ Table.States (777).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (777), 118, 131);
+ Add_Goto (Table.States (777), 129, 42);
+ Add_Goto (Table.States (777), 192, 132);
+ Add_Goto (Table.States (777), 193, 963);
+ Add_Goto (Table.States (777), 198, 134);
+ Add_Goto (Table.States (777), 240, 135);
+ Add_Goto (Table.States (777), 259, 136);
+ Add_Goto (Table.States (777), 273, 93);
+ Add_Goto (Table.States (777), 276, 137);
+ Add_Goto (Table.States (777), 283, 138);
+ Add_Goto (Table.States (777), 284, 139);
+ Add_Goto (Table.States (777), 285, 140);
+ Add_Goto (Table.States (777), 286, 141);
+ Add_Goto (Table.States (777), 287, 142);
+ Add_Goto (Table.States (777), 288, 143);
+ Add_Goto (Table.States (777), 294, 98);
+ Add_Goto (Table.States (777), 302, 144);
+ Add_Goto (Table.States (777), 321, 145);
+ Add_Goto (Table.States (777), 322, 146);
+ Add_Goto (Table.States (777), 331, 147);
+ Table.States (777).Kernel := To_Vector ((0 => (278, 76, 1,
False)));
+ Table.States (777).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (778).Action_List.Set_Capacity (25);
+ Add_Action (Table.States (778), 4, 1);
+ Add_Action (Table.States (778), 5, 2);
+ Add_Action (Table.States (778), 13, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (778), 15, 3);
+ Add_Action (Table.States (778), 17, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (778), 18, 4);
+ Add_Action (Table.States (778), 24, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (778), 27, 5);
+ Add_Action (Table.States (778), 28, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (778), 31, 9);
+ Add_Action (Table.States (778), 32, 10);
+ Add_Action (Table.States (778), 37, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (778), 41, 13);
+ Add_Action (Table.States (778), 48, 16);
+ Add_Action (Table.States (778), 52, 20);
+ Add_Action (Table.States (778), 57, 21);
+ Add_Action (Table.States (778), 58, 22);
+ Add_Action (Table.States (778), 61, 24);
+ Add_Action (Table.States (778), 72, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (778), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (778), 79, 31);
+ Add_Action (Table.States (778), 94, 32);
+ Add_Action (Table.States (778), 105, 361);
+ Add_Action (Table.States (778), 106, 34);
+ Add_Action (Table.States (778), 107, 35);
+ Table.States (778).Goto_List.Set_Capacity (31);
+ Add_Goto (Table.States (778), 114, 37);
+ Add_Goto (Table.States (778), 124, 39);
+ Add_Goto (Table.States (778), 127, 40);
+ Add_Goto (Table.States (778), 129, 42);
+ Add_Goto (Table.States (778), 132, 43);
+ Add_Goto (Table.States (778), 133, 44);
+ Add_Goto (Table.States (778), 134, 45);
+ Add_Goto (Table.States (778), 140, 48);
+ Add_Goto (Table.States (778), 152, 51);
+ Add_Goto (Table.States (778), 153, 52);
+ Add_Goto (Table.States (778), 162, 54);
+ Add_Goto (Table.States (778), 191, 58);
+ Add_Goto (Table.States (778), 197, 60);
+ Add_Goto (Table.States (778), 218, 69);
+ Add_Goto (Table.States (778), 223, 71);
+ Add_Goto (Table.States (778), 233, 73);
+ Add_Goto (Table.States (778), 240, 74);
+ Add_Goto (Table.States (778), 258, 84);
+ Add_Goto (Table.States (778), 262, 87);
+ Add_Goto (Table.States (778), 273, 93);
+ Add_Goto (Table.States (778), 277, 94);
+ Add_Goto (Table.States (778), 291, 97);
+ Add_Goto (Table.States (778), 294, 98);
+ Add_Goto (Table.States (778), 295, 99);
+ Add_Goto (Table.States (778), 299, 100);
+ Add_Goto (Table.States (778), 300, 362);
+ Add_Goto (Table.States (778), 301, 964);
+ Add_Goto (Table.States (778), 303, 101);
+ Add_Goto (Table.States (778), 304, 102);
+ Add_Goto (Table.States (778), 307, 364);
+ Add_Goto (Table.States (778), 324, 115);
+ Table.States (778).Kernel := To_Vector ((0 => (141, 88, 0,
False)));
+ Table.States (778).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 301, 0)));
+ Table.States (779).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (779), 97, 965);
+ Table.States (779).Kernel := To_Vector ((0 => (140, 15, 1,
False)));
+ Table.States (779).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 965)));
+ Table.States (780).Action_List.Set_Capacity (17);
+ Add_Action (Table.States (780), (10, 20, 21, 22, 23, 35, 37, 43,
53, 68, 74, 75, 77, 80, 84, 88, 97), (234,
0), 3, null, null);
- Table.States (772).Kernel := To_Vector ((0 => (233, 234, 0,
True)));
- Table.States (772).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 233, 3)));
- Table.States (772).Minimal_Complete_Actions_Recursive := True;
- Table.States (773).Action_List.Set_Capacity (15);
- Add_Action (Table.States (773), 10, Reduce, (314, 1), 3,
subtype_indication_1'Access, null);
- Add_Action (Table.States (773), 21, Reduce, (314, 1), 3,
subtype_indication_1'Access, null);
- Add_Action (Table.States (773), 37, Reduce, (314, 1), 3,
subtype_indication_1'Access, null);
- Add_Action (Table.States (773), 42, Reduce, (314, 1), 3,
subtype_indication_1'Access, null);
- Add_Action (Table.States (773), 53, 620);
- Add_Action (Table.States (773), 74, Reduce, (314, 1), 3,
subtype_indication_1'Access, null);
- Add_Action (Table.States (773), 76, 621);
- Add_Action (Table.States (773), 77, Reduce, (314, 1), 3,
subtype_indication_1'Access, null);
- Add_Action (Table.States (773), 82, Reduce, (314, 1), 3,
subtype_indication_1'Access, null);
- Add_Action (Table.States (773), 83, Reduce, (314, 1), 3,
subtype_indication_1'Access, null);
- Add_Action (Table.States (773), 84, 237);
- Add_Action (Table.States (773), 87, Reduce, (314, 1), 3,
subtype_indication_1'Access, null);
- Add_Action (Table.States (773), 96, Reduce, (314, 1), 3,
subtype_indication_1'Access, null);
- Add_Action (Table.States (773), 101, 239);
- Add_Action (Table.States (773), 102, 240);
- Table.States (773).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (773), 115, 241);
- Add_Goto (Table.States (773), 155, 956);
- Add_Goto (Table.States (773), 224, 623);
- Add_Goto (Table.States (773), 322, 242);
- Table.States (773).Kernel := To_Vector (((128, 239, 2, True),
(239, 239, 5, True), (239, 239, 2, True),
- (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (314, 239, 4, False), (314, 239, 0, False)));
- Table.States (773).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 314, 3)));
- Table.States (774).Action_List.Set_Capacity (10);
- Add_Action (Table.States (774), (10, 21, 37, 42, 74, 77, 82, 83,
87, 96), (155, 0), 2, null, null);
- Table.States (774).Kernel := To_Vector ((0 => (155, 277, 0,
False)));
- Table.States (774).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 155, 2)));
- Table.States (775).Action_List.Set_Capacity (7);
- Add_Action (Table.States (775), 39, 122);
- Add_Action (Table.States (775), 41, 957);
- Add_Action (Table.States (775), 76, 126);
- Add_Action (Table.States (775), 103, 129);
- Add_Action (Table.States (775), 104, 119);
- Add_Action (Table.States (775), 105, 33);
- Add_Action (Table.States (775), 106, 34);
- Table.States (775).Goto_List.Set_Capacity (6);
- Add_Goto (Table.States (775), 117, 130);
- Add_Goto (Table.States (775), 128, 41);
- Add_Goto (Table.States (775), 239, 134);
- Add_Goto (Table.States (775), 258, 256);
- Add_Goto (Table.States (775), 272, 92);
- Add_Goto (Table.States (775), 293, 97);
- Table.States (775).Kernel := To_Vector (((165, 40, 2, False),
(197, 40, 1, False), (314, 40, 6, False),
- (314, 40, 2, False)));
- Table.States (775).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
- Table.States (776).Action_List.Set_Capacity (2);
- Add_Action (Table.States (776), (77, 83), (168, 1), 1, null, null);
- Table.States (776).Kernel := To_Vector ((0 => (168, 167, 0,
False)));
- Table.States (776).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 168, 1)));
- Table.States (777).Action_List.Set_Capacity (2);
- Add_Action (Table.States (777), 77, 958);
- Add_Action (Table.States (777), 83, 959);
- Table.States (777).Kernel := To_Vector (((168, 168, 2, True),
(224, 168, 1, False)));
- Table.States (777).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 958)));
- Table.States (778).Action_List.Set_Capacity (4);
- Add_Action (Table.States (778), 77, Reduce, (167, 1), 1, null,
null);
- Add_Conflict (Table.States (778), 77, (278, 1), 1, null, null);
- Add_Action (Table.States (778), 79, Reduce, (165, 2), 1, null,
null);
- Add_Action (Table.States (778), 83, Reduce, (167, 1), 1, null,
null);
- Add_Conflict (Table.States (778), 83, (278, 1), 1, null, null);
- Add_Action (Table.States (778), 87, Reduce, (165, 2), 1, null,
null);
- Table.States (778).Kernel := To_Vector (((165, 277, 0, False),
(167, 277, 0, False), (278, 277, 0,
- False)));
- Table.States (778).Minimal_Complete_Actions := To_Vector
(((Reduce, 165, 1), (Reduce, 167, 1), (Reduce,
- 278, 1)));
- Table.States (779).Action_List.Set_Capacity (3);
- Add_Action (Table.States (779), 104, 119);
- Add_Action (Table.States (779), 105, 33);
- Add_Action (Table.States (779), 106, 34);
- Table.States (779).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (779), 128, 41);
- Add_Goto (Table.States (779), 239, 960);
- Add_Goto (Table.States (779), 272, 92);
- Add_Goto (Table.States (779), 293, 97);
- Table.States (779).Kernel := To_Vector ((0 => (230, 59, 1,
False)));
- Table.States (779).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (780).Action_List.Set_Capacity (6);
- Add_Action (Table.States (780), 37, Reduce, (230, 1), 5, null,
null);
- Add_Action (Table.States (780), 76, 235);
- Add_Action (Table.States (780), 84, 237);
- Add_Action (Table.States (780), 87, Reduce, (230, 1), 5, null,
null);
- Add_Action (Table.States (780), 101, 239);
- Add_Action (Table.States (780), 102, 240);
- Table.States (780).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (780), 115, 241);
- Add_Goto (Table.States (780), 322, 242);
- Table.States (780).Kernel := To_Vector (((128, 239, 2, True),
(230, 239, 0, False), (239, 239, 5, True),
- (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (780).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 230, 5)));
- Table.States (781).Action_List.Set_Capacity (41);
- Add_Action (Table.States (781), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73,
74, 93, 104, 105, 106, 107), (127, 0), 6,
- at_clause_0'Access, null);
- Table.States (781).Kernel := To_Vector ((0 => (127, 96, 0,
False)));
- Table.States (781).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 127, 6)));
- Table.States (782).Action_List.Set_Capacity (13);
- Add_Action (Table.States (782), 3, 121);
- Add_Action (Table.States (782), 39, 122);
- Add_Action (Table.States (782), 40, 123);
- Add_Action (Table.States (782), 41, 124);
- Add_Action (Table.States (782), 52, 125);
- Add_Action (Table.States (782), 76, 126);
- Add_Action (Table.States (782), 94, 127);
- Add_Action (Table.States (782), 95, 128);
- Add_Action (Table.States (782), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (782), 103, 129);
- Add_Action (Table.States (782), 104, 119);
- Add_Action (Table.States (782), 105, 33);
- Add_Action (Table.States (782), 106, 34);
- Table.States (782).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (782), 117, 130);
- Add_Goto (Table.States (782), 128, 41);
- Add_Goto (Table.States (782), 191, 131);
- Add_Goto (Table.States (782), 192, 961);
- Add_Goto (Table.States (782), 197, 133);
- Add_Goto (Table.States (782), 239, 134);
- Add_Goto (Table.States (782), 258, 135);
- Add_Goto (Table.States (782), 272, 92);
- Add_Goto (Table.States (782), 275, 136);
- Add_Goto (Table.States (782), 282, 137);
- Add_Goto (Table.States (782), 283, 138);
- Add_Goto (Table.States (782), 284, 139);
- Add_Goto (Table.States (782), 285, 140);
- Add_Goto (Table.States (782), 286, 141);
- Add_Goto (Table.States (782), 287, 142);
- Add_Goto (Table.States (782), 293, 97);
- Add_Goto (Table.States (782), 301, 143);
- Add_Goto (Table.States (782), 320, 144);
- Add_Goto (Table.States (782), 321, 145);
- Add_Goto (Table.States (782), 330, 146);
- Table.States (782).Kernel := To_Vector ((0 => (235, 38, 1,
False)));
- Table.States (782).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (783).Action_List.Set_Capacity (1);
- Add_Action (Table.States (783), 12, 962);
- Table.States (783).Kernel := To_Vector ((0 => (144, 104, 7,
False)));
- Table.States (783).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 12, 962)));
+ Table.States (780).Kernel := To_Vector ((0 => (234, 235, 0,
True)));
+ Table.States (780).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 234, 3)));
+ Table.States (780).Minimal_Complete_Actions_Recursive := True;
+ end Subr_14;
+ procedure Subr_15
+ is begin
+ Table.States (781).Action_List.Set_Capacity (15);
+ Add_Action (Table.States (781), 10, Reduce, (315, 1), 3,
subtype_indication_1'Access, null);
+ Add_Action (Table.States (781), 21, Reduce, (315, 1), 3,
subtype_indication_1'Access, null);
+ Add_Action (Table.States (781), 37, Reduce, (315, 1), 3,
subtype_indication_1'Access, null);
+ Add_Action (Table.States (781), 42, Reduce, (315, 1), 3,
subtype_indication_1'Access, null);
+ Add_Action (Table.States (781), 53, 626);
+ Add_Action (Table.States (781), 74, Reduce, (315, 1), 3,
subtype_indication_1'Access, null);
+ Add_Action (Table.States (781), 76, 627);
+ Add_Action (Table.States (781), 77, Reduce, (315, 1), 3,
subtype_indication_1'Access, null);
+ Add_Action (Table.States (781), 83, Reduce, (315, 1), 3,
subtype_indication_1'Access, null);
+ Add_Action (Table.States (781), 84, Reduce, (315, 1), 3,
subtype_indication_1'Access, null);
+ Add_Action (Table.States (781), 85, 238);
+ Add_Action (Table.States (781), 88, Reduce, (315, 1), 3,
subtype_indication_1'Access, null);
+ Add_Action (Table.States (781), 97, Reduce, (315, 1), 3,
subtype_indication_1'Access, null);
+ Add_Action (Table.States (781), 102, 240);
+ Add_Action (Table.States (781), 103, 241);
+ Table.States (781).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (781), 116, 242);
+ Add_Goto (Table.States (781), 156, 966);
+ Add_Goto (Table.States (781), 225, 629);
+ Add_Goto (Table.States (781), 323, 243);
+ Table.States (781).Kernel := To_Vector (((129, 240, 2, True),
(240, 240, 5, True), (240, 240, 2, True),
+ (273, 240, 3, True), (294, 240, 2, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (315, 240, 4, False), (315, 240, 0, False)));
+ Table.States (781).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 315, 3)));
+ Table.States (782).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (782), (10, 21, 37, 42, 74, 77, 83, 84,
88, 97), (156, 0), 2, null, null);
+ Table.States (782).Kernel := To_Vector ((0 => (156, 278, 0,
False)));
+ Table.States (782).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 156, 2)));
+ Table.States (783).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (783), 39, 123);
+ Add_Action (Table.States (783), 41, 967);
+ Add_Action (Table.States (783), 76, 127);
+ Add_Action (Table.States (783), 79, 31);
+ Add_Action (Table.States (783), 104, 130);
+ Add_Action (Table.States (783), 105, 120);
+ Add_Action (Table.States (783), 106, 34);
+ Add_Action (Table.States (783), 107, 35);
+ Table.States (783).Goto_List.Set_Capacity (6);
+ Add_Goto (Table.States (783), 118, 131);
+ Add_Goto (Table.States (783), 129, 42);
+ Add_Goto (Table.States (783), 240, 135);
+ Add_Goto (Table.States (783), 259, 257);
+ Add_Goto (Table.States (783), 273, 93);
+ Add_Goto (Table.States (783), 294, 98);
+ Table.States (783).Kernel := To_Vector (((166, 40, 2, False),
(198, 40, 1, False), (315, 40, 6, False),
+ (315, 40, 2, False)));
+ Table.States (783).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
Table.States (784).Action_List.Set_Capacity (2);
- Add_Action (Table.States (784), (24, 104), (145, 1), 1, null,
null);
- Table.States (784).Kernel := To_Vector ((0 => (145, 144, 0,
False)));
- Table.States (784).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 145, 1)));
+ Add_Action (Table.States (784), (77, 84), (169, 1), 1, null, null);
+ Table.States (784).Kernel := To_Vector ((0 => (169, 168, 0,
False)));
+ Table.States (784).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 169, 1)));
Table.States (785).Action_List.Set_Capacity (2);
- Add_Action (Table.States (785), 24, 963);
- Add_Action (Table.States (785), 104, 783);
- Table.States (785).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (785), 144, 964);
- Table.States (785).Kernel := To_Vector (((145, 145, 8, True),
(281, 145, 3, False)));
- Table.States (785).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 963)));
- Table.States (786).Action_List.Set_Capacity (7);
- Add_Action (Table.States (786), 7, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (786), 33, 504);
- Add_Action (Table.States (786), 40, 386);
- Add_Conflict (Table.States (786), 40, (236, 3), 0, null, null);
- Add_Action (Table.States (786), 45, 505);
- Add_Action (Table.States (786), 104, Reduce, (236, 3), 0, null,
null);
- Add_Action (Table.States (786), 105, Reduce, (236, 3), 0, null,
null);
- Add_Action (Table.States (786), 106, Reduce, (236, 3), 0, null,
null);
- Table.States (786).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (786), 114, 965);
- Add_Goto (Table.States (786), 236, 966);
- Add_Goto (Table.States (786), 241, 723);
- Table.States (786).Kernel := To_Vector (((254, 118, 2, False),
(254, 118, 1, False), (254, 118, 3, False),
- (254, 118, 2, False)));
- Table.States (786).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 236, 0)));
- Table.States (787).Action_List.Set_Capacity (2);
- Add_Action (Table.States (787), (77, 96), (255, 0), 3, null, null);
- Table.States (787).Kernel := To_Vector ((0 => (255, 254, 0,
True)));
- Table.States (787).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 255, 3)));
- Table.States (787).Minimal_Complete_Actions_Recursive := True;
- Table.States (788).Action_List.Set_Capacity (1);
- Add_Action (Table.States (788), 96, 967);
- Table.States (788).Kernel := To_Vector ((0 => (215, 122, 1,
False)));
- Table.States (788).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 967)));
- Table.States (789).Action_List.Set_Capacity (1);
- Add_Action (Table.States (789), 96, 968);
- Table.States (789).Kernel := To_Vector ((0 => (215, 122, 1,
False)));
- Table.States (789).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 968)));
- Table.States (790).Action_List.Set_Capacity (1);
- Add_Action (Table.States (790), 96, 969);
- Table.States (790).Kernel := To_Vector ((0 => (215, 122, 1,
False)));
- Table.States (790).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 969)));
- Table.States (791).Action_List.Set_Capacity (4);
- Add_Action (Table.States (791), 36, 970);
- Add_Action (Table.States (791), 39, Reduce, (109, 2), 1, null,
null);
- Add_Action (Table.States (791), 64, 876);
- Add_Action (Table.States (791), 65, 877);
- Table.States (791).Kernel := To_Vector (((109, 6, 1, False), (109,
6, 1, False), (109, 6, 0, False), (111,
- 6, 2, False), (111, 6, 1, False)));
- Table.States (791).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 109, 1)));
- Table.States (792).Action_List.Set_Capacity (1);
- Add_Action (Table.States (792), 80, 971);
- Table.States (792).Kernel := To_Vector (((202, 19, 3, False),
(202, 19, 1, False)));
- Table.States (792).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 80, 971)));
- Table.States (793).Action_List.Set_Capacity (1);
- Add_Action (Table.States (793), 80, 972);
- Table.States (793).Kernel := To_Vector ((0 => (202, 20, 1,
False)));
- Table.States (793).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 80, 972)));
- Table.States (794).Action_List.Set_Capacity (3);
- Add_Action (Table.States (794), 34, 881);
- Add_Action (Table.States (794), 39, Reduce, (109, 3), 1, null,
null);
- Add_Action (Table.States (794), 49, Reduce, (111, 4), 1, null,
null);
- Table.States (794).Kernel := To_Vector (((109, 36, 0, False),
(111, 36, 0, False), (228, 36, 3, False),
- (228, 36, 1, False)));
- Table.States (794).Minimal_Complete_Actions := To_Vector
(((Reduce, 109, 1), (Reduce, 111, 1)));
- Table.States (795).Action_List.Set_Capacity (1);
- Add_Action (Table.States (795), 80, 973);
- Table.States (795).Kernel := To_Vector ((0 => (202, 38, 1,
False)));
- Table.States (795).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 80, 973)));
+ Add_Action (Table.States (785), 77, 968);
+ Add_Action (Table.States (785), 84, 969);
+ Table.States (785).Kernel := To_Vector (((169, 169, 2, True),
(225, 169, 1, False)));
+ Table.States (785).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 968)));
+ Table.States (786).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (786), 77, Reduce, (168, 1), 1, null,
null);
+ Add_Conflict (Table.States (786), 77, (279, 1), 1, null, null);
+ Add_Action (Table.States (786), 80, Reduce, (166, 2), 1, null,
null);
+ Add_Action (Table.States (786), 84, Reduce, (168, 1), 1, null,
null);
+ Add_Conflict (Table.States (786), 84, (279, 1), 1, null, null);
+ Add_Action (Table.States (786), 88, Reduce, (166, 2), 1, null,
null);
+ Table.States (786).Kernel := To_Vector (((166, 278, 0, False),
(168, 278, 0, False), (279, 278, 0,
+ False)));
+ Table.States (786).Minimal_Complete_Actions := To_Vector
(((Reduce, 166, 1), (Reduce, 168, 1), (Reduce,
+ 279, 1)));
+ Table.States (787).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (787), 79, 31);
+ Add_Action (Table.States (787), 105, 120);
+ Add_Action (Table.States (787), 106, 34);
+ Add_Action (Table.States (787), 107, 35);
+ Table.States (787).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (787), 129, 42);
+ Add_Goto (Table.States (787), 240, 970);
+ Add_Goto (Table.States (787), 273, 93);
+ Add_Goto (Table.States (787), 294, 98);
+ Table.States (787).Kernel := To_Vector ((0 => (231, 59, 1,
False)));
+ Table.States (787).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (788).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (788), 37, Reduce, (231, 1), 5, null,
null);
+ Add_Action (Table.States (788), 76, 236);
+ Add_Action (Table.States (788), 85, 238);
+ Add_Action (Table.States (788), 88, Reduce, (231, 1), 5, null,
null);
+ Add_Action (Table.States (788), 102, 240);
+ Add_Action (Table.States (788), 103, 241);
+ Table.States (788).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (788), 116, 242);
+ Add_Goto (Table.States (788), 323, 243);
+ Table.States (788).Kernel := To_Vector (((129, 240, 2, True),
(231, 240, 0, False), (240, 240, 5, True),
+ (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (788).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 231, 5)));
+ Table.States (789).Action_List.Set_Capacity (42);
+ Add_Action (Table.States (789), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73,
74, 79, 94, 105, 106, 107, 108), (128, 0),
+ 6, at_clause_0'Access, null);
+ Table.States (789).Kernel := To_Vector ((0 => (128, 97, 0,
False)));
+ Table.States (789).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 128, 6)));
+ Table.States (790).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (790), 3, 122);
+ Add_Action (Table.States (790), 39, 123);
+ Add_Action (Table.States (790), 40, 124);
+ Add_Action (Table.States (790), 41, 125);
+ Add_Action (Table.States (790), 52, 126);
+ Add_Action (Table.States (790), 76, 127);
+ Add_Action (Table.States (790), 79, 31);
+ Add_Action (Table.States (790), 95, 128);
+ Add_Action (Table.States (790), 96, 129);
+ Add_Action (Table.States (790), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (790), 104, 130);
+ Add_Action (Table.States (790), 105, 120);
+ Add_Action (Table.States (790), 106, 34);
+ Add_Action (Table.States (790), 107, 35);
+ Table.States (790).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (790), 118, 131);
+ Add_Goto (Table.States (790), 129, 42);
+ Add_Goto (Table.States (790), 192, 132);
+ Add_Goto (Table.States (790), 193, 971);
+ Add_Goto (Table.States (790), 198, 134);
+ Add_Goto (Table.States (790), 240, 135);
+ Add_Goto (Table.States (790), 259, 136);
+ Add_Goto (Table.States (790), 273, 93);
+ Add_Goto (Table.States (790), 276, 137);
+ Add_Goto (Table.States (790), 283, 138);
+ Add_Goto (Table.States (790), 284, 139);
+ Add_Goto (Table.States (790), 285, 140);
+ Add_Goto (Table.States (790), 286, 141);
+ Add_Goto (Table.States (790), 287, 142);
+ Add_Goto (Table.States (790), 288, 143);
+ Add_Goto (Table.States (790), 294, 98);
+ Add_Goto (Table.States (790), 302, 144);
+ Add_Goto (Table.States (790), 321, 145);
+ Add_Goto (Table.States (790), 322, 146);
+ Add_Goto (Table.States (790), 331, 147);
+ Table.States (790).Kernel := To_Vector ((0 => (236, 38, 1,
False)));
+ Table.States (790).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (791).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (791), 12, 972);
+ Table.States (791).Kernel := To_Vector ((0 => (145, 105, 7,
False)));
+ Table.States (791).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 12, 972)));
+ Table.States (792).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (792), (24, 105), (146, 1), 1, null,
null);
+ Table.States (792).Kernel := To_Vector ((0 => (146, 145, 0,
False)));
+ Table.States (792).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 146, 1)));
+ Table.States (793).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (793), 24, 973);
+ Add_Action (Table.States (793), 105, 791);
+ Table.States (793).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (793), 145, 974);
+ Table.States (793).Kernel := To_Vector (((146, 146, 8, True),
(282, 146, 3, False)));
+ Table.States (793).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 973)));
+ Table.States (794).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (794), 7, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (794), 33, 507);
+ Add_Action (Table.States (794), 40, 387);
+ Add_Conflict (Table.States (794), 40, (237, 3), 0, null, null);
+ Add_Action (Table.States (794), 45, 508);
+ Add_Action (Table.States (794), 79, Reduce, (237, 3), 0, null,
null);
+ Add_Action (Table.States (794), 105, Reduce, (237, 3), 0, null,
null);
+ Add_Action (Table.States (794), 106, Reduce, (237, 3), 0, null,
null);
+ Add_Action (Table.States (794), 107, Reduce, (237, 3), 0, null,
null);
+ Table.States (794).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (794), 115, 975);
+ Add_Goto (Table.States (794), 237, 976);
+ Add_Goto (Table.States (794), 242, 729);
+ Table.States (794).Kernel := To_Vector (((255, 119, 2, False),
(255, 119, 1, False), (255, 119, 3, False),
+ (255, 119, 2, False)));
+ Table.States (794).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 237, 0)));
+ Table.States (795).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (795), (77, 97), (256, 0), 3, null, null);
+ Table.States (795).Kernel := To_Vector ((0 => (256, 255, 0,
True)));
+ Table.States (795).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 256, 3)));
+ Table.States (795).Minimal_Complete_Actions_Recursive := True;
Table.States (796).Action_List.Set_Capacity (1);
- Add_Action (Table.States (796), 80, 974);
- Table.States (796).Kernel := To_Vector ((0 => (202, 53, 1,
False)));
- Table.States (796).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 80, 974)));
- Table.States (797).Action_List.Set_Capacity (4);
- Add_Action (Table.States (797), 36, 896);
- Add_Action (Table.States (797), 49, Reduce, (111, 3), 1, null,
null);
- Add_Action (Table.States (797), 74, 337);
- Add_Action (Table.States (797), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (797).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (797), 122, 975);
- Table.States (797).Kernel := To_Vector (((111, 65, 1, False),
(111, 65, 0, False), (201, 65, 1, False)));
- Table.States (797).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 111, 1)));
+ Add_Action (Table.States (796), 97, 977);
+ Table.States (796).Kernel := To_Vector ((0 => (216, 123, 1,
False)));
+ Table.States (796).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 977)));
+ Table.States (797).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (797), 97, 978);
+ Table.States (797).Kernel := To_Vector ((0 => (216, 123, 1,
False)));
+ Table.States (797).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 978)));
Table.States (798).Action_List.Set_Capacity (1);
- Add_Action (Table.States (798), 80, 976);
- Table.States (798).Kernel := To_Vector ((0 => (202, 76, 2,
False)));
- Table.States (798).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 80, 976)));
- Table.States (799).Action_List.Set_Capacity (1);
- Add_Action (Table.States (799), 39, 977);
- Table.States (799).Kernel := To_Vector (((203, 109, 4, False),
(203, 109, 2, False)));
- Table.States (799).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 39, 977)));
+ Add_Action (Table.States (798), 97, 979);
+ Table.States (798).Kernel := To_Vector ((0 => (216, 123, 1,
False)));
+ Table.States (798).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 979)));
+ Table.States (799).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (799), 36, 980);
+ Add_Action (Table.States (799), 39, Reduce, (110, 2), 1, null,
null);
+ Add_Action (Table.States (799), 64, 884);
+ Add_Action (Table.States (799), 65, 885);
+ Table.States (799).Kernel := To_Vector (((110, 6, 1, False), (110,
6, 1, False), (110, 6, 0, False), (112,
+ 6, 2, False), (112, 6, 1, False)));
+ Table.States (799).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 110, 1)));
Table.States (800).Action_List.Set_Capacity (1);
- Add_Action (Table.States (800), 49, 978);
- Table.States (800).Kernel := To_Vector ((0 => (202, 111, 1,
False)));
- Table.States (800).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 49, 978)));
- Table.States (801).Action_List.Set_Capacity (2);
- Add_Action (Table.States (801), (74, 96), (202, 9), 1, null, null);
- Table.States (801).Kernel := To_Vector ((0 => (202, 114, 0,
False)));
- Table.States (801).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 202, 1)));
- Table.States (802).Action_List.Set_Capacity (2);
- Add_Action (Table.States (802), (74, 96), (202, 8), 1, null, null);
- Table.States (802).Kernel := To_Vector ((0 => (202, 120, 0,
False)));
- Table.States (802).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 202, 1)));
- Table.States (803).Action_List.Set_Capacity (2);
- Add_Action (Table.States (803), 74, 337);
- Add_Action (Table.States (803), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (803).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (803), 122, 979);
- Table.States (803).Kernel := To_Vector ((0 => (201, 202, 1,
False)));
- Table.States (803).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (804).Action_List.Set_Capacity (2);
- Add_Action (Table.States (804), (74, 96), (202, 1), 1, null, null);
- Table.States (804).Kernel := To_Vector ((0 => (202, 203, 0,
False)));
- Table.States (804).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 202, 1)));
- Table.States (805).Action_List.Set_Capacity (2);
- Add_Action (Table.States (805), (74, 96), (202, 10), 1, null,
null);
- Table.States (805).Kernel := To_Vector ((0 => (202, 228, 0,
False)));
- Table.States (805).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 202, 1)));
- Table.States (806).Action_List.Set_Capacity (8);
- Add_Action (Table.States (806), (29, 47, 48, 50, 69, 71, 74, 104),
(201, 2), 5,
- formal_type_declaration_2'Access, null);
- Table.States (806).Kernel := To_Vector ((0 => (201, 96, 0,
False)));
- Table.States (806).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 201, 5)));
- Table.States (807).Action_List.Set_Capacity (3);
- Add_Action (Table.States (807), 104, 119);
- Add_Action (Table.States (807), 105, 33);
- Add_Action (Table.States (807), 106, 34);
- Table.States (807).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (807), 128, 41);
- Add_Goto (Table.States (807), 239, 980);
- Add_Goto (Table.States (807), 272, 92);
- Add_Goto (Table.States (807), 293, 97);
- Table.States (807).Kernel := To_Vector ((0 => (204, 39, 2,
False)));
- Table.States (807).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
+ Add_Action (Table.States (800), 81, 981);
+ Table.States (800).Kernel := To_Vector (((203, 19, 3, False),
(203, 19, 1, False)));
+ Table.States (800).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 81, 981)));
+ Table.States (801).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (801), 81, 982);
+ Table.States (801).Kernel := To_Vector ((0 => (203, 20, 1,
False)));
+ Table.States (801).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 81, 982)));
+ Table.States (802).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (802), 34, 889);
+ Add_Action (Table.States (802), 39, Reduce, (110, 3), 1, null,
null);
+ Add_Action (Table.States (802), 49, Reduce, (112, 4), 1, null,
null);
+ Table.States (802).Kernel := To_Vector (((110, 36, 0, False),
(112, 36, 0, False), (229, 36, 3, False),
+ (229, 36, 1, False)));
+ Table.States (802).Minimal_Complete_Actions := To_Vector
(((Reduce, 110, 1), (Reduce, 112, 1)));
+ Table.States (803).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (803), 81, 983);
+ Table.States (803).Kernel := To_Vector ((0 => (203, 38, 1,
False)));
+ Table.States (803).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 81, 983)));
+ Table.States (804).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (804), 81, 984);
+ Table.States (804).Kernel := To_Vector ((0 => (203, 53, 1,
False)));
+ Table.States (804).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 81, 984)));
+ Table.States (805).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (805), 36, 904);
+ Add_Action (Table.States (805), 49, Reduce, (112, 3), 1, null,
null);
+ Add_Action (Table.States (805), 74, 338);
+ Add_Action (Table.States (805), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (805).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (805), 123, 985);
+ Table.States (805).Kernel := To_Vector (((112, 65, 1, False),
(112, 65, 0, False), (202, 65, 1, False)));
+ Table.States (805).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 112, 1)));
+ Table.States (806).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (806), 81, 986);
+ Table.States (806).Kernel := To_Vector ((0 => (203, 76, 2,
False)));
+ Table.States (806).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 81, 986)));
+ Table.States (807).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (807), 39, 987);
+ Table.States (807).Kernel := To_Vector (((204, 110, 4, False),
(204, 110, 2, False)));
+ Table.States (807).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 39, 987)));
Table.States (808).Action_List.Set_Capacity (1);
- Add_Action (Table.States (808), 96, 981);
- Table.States (808).Kernel := To_Vector ((0 => (200, 122, 1,
False)));
- Table.States (808).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 981)));
+ Add_Action (Table.States (808), 49, 988);
+ Table.States (808).Kernel := To_Vector ((0 => (203, 112, 1,
False)));
+ Table.States (808).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 49, 988)));
Table.States (809).Action_List.Set_Capacity (2);
- Add_Action (Table.States (809), 74, 337);
- Add_Action (Table.States (809), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (809).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (809), 122, 982);
- Table.States (809).Kernel := To_Vector ((0 => (200, 310, 1,
False)));
- Table.States (809).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (810).Action_List.Set_Capacity (1);
- Add_Action (Table.States (810), 96, 983);
- Table.States (810).Kernel := To_Vector ((0 => (200, 122, 1,
False)));
- Table.States (810).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 983)));
- Table.States (811).Action_List.Set_Capacity (14);
- Add_Action (Table.States (811), 3, 121);
- Add_Action (Table.States (811), 39, 122);
- Add_Action (Table.States (811), 40, 123);
- Add_Action (Table.States (811), 41, 124);
- Add_Action (Table.States (811), 52, 125);
- Add_Action (Table.States (811), 74, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (811), 76, 126);
- Add_Action (Table.States (811), 94, 127);
- Add_Action (Table.States (811), 95, 128);
- Add_Action (Table.States (811), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (811), 103, 129);
- Add_Action (Table.States (811), 104, 119);
- Add_Action (Table.States (811), 105, 33);
- Add_Action (Table.States (811), 106, 34);
- Table.States (811).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (811), 117, 130);
- Add_Goto (Table.States (811), 128, 41);
- Add_Goto (Table.States (811), 191, 131);
- Add_Goto (Table.States (811), 192, 984);
- Add_Goto (Table.States (811), 197, 133);
- Add_Goto (Table.States (811), 239, 134);
- Add_Goto (Table.States (811), 258, 135);
- Add_Goto (Table.States (811), 272, 92);
- Add_Goto (Table.States (811), 275, 136);
- Add_Goto (Table.States (811), 282, 137);
- Add_Goto (Table.States (811), 283, 138);
- Add_Goto (Table.States (811), 284, 139);
- Add_Goto (Table.States (811), 285, 140);
- Add_Goto (Table.States (811), 286, 141);
- Add_Goto (Table.States (811), 287, 142);
- Add_Goto (Table.States (811), 293, 97);
- Add_Goto (Table.States (811), 301, 143);
- Add_Goto (Table.States (811), 320, 144);
- Add_Goto (Table.States (811), 321, 145);
- Add_Goto (Table.States (811), 330, 146);
- Table.States (811).Kernel := To_Vector ((0 => (198, 82, 1,
False)));
- Table.States (811).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (812).Action_List.Set_Capacity (1);
- Add_Action (Table.States (812), 96, 985);
- Table.States (812).Kernel := To_Vector ((0 => (198, 122, 1,
False)));
- Table.States (812).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 985)));
- Table.States (813).Action_List.Set_Capacity (7);
- Add_Action (Table.States (813), 74, 337);
- Add_Action (Table.States (813), 76, 235);
- Add_Action (Table.States (813), 82, 986);
- Add_Action (Table.States (813), 84, 237);
- Add_Action (Table.States (813), 96, Reduce, (122, 1), 0, null,
null);
- Add_Action (Table.States (813), 101, 239);
- Add_Action (Table.States (813), 102, 240);
- Table.States (813).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (813), 115, 241);
- Add_Goto (Table.States (813), 122, 987);
- Add_Goto (Table.States (813), 322, 242);
- Table.States (813).Kernel := To_Vector (((128, 239, 2, True),
(198, 239, 2, False), (198, 239, 1, False),
- (239, 239, 5, True), (239, 239, 2, True), (272, 239, 3, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True), (293, 239, 2, True)));
- Table.States (813).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (814).Action_List.Set_Capacity (1);
- Add_Action (Table.States (814), 24, 988);
- Table.States (814).Kernel := To_Vector ((0 => (222, 300, 3,
False)));
- Table.States (814).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 988)));
- Table.States (815).Action_List.Set_Capacity (1);
- Add_Action (Table.States (815), 68, 989);
- Table.States (815).Kernel := To_Vector ((0 => (174, 192, 1,
False)));
- Table.States (815).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 68, 989)));
+ Add_Action (Table.States (809), (74, 97), (203, 9), 1, null, null);
+ Table.States (809).Kernel := To_Vector ((0 => (203, 115, 0,
False)));
+ Table.States (809).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 203, 1)));
+ Table.States (810).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (810), (74, 97), (203, 8), 1, null, null);
+ Table.States (810).Kernel := To_Vector ((0 => (203, 121, 0,
False)));
+ Table.States (810).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 203, 1)));
+ Table.States (811).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (811), 74, 338);
+ Add_Action (Table.States (811), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (811).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (811), 123, 989);
+ Table.States (811).Kernel := To_Vector ((0 => (202, 203, 1,
False)));
+ Table.States (811).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (812).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (812), (74, 97), (203, 1), 1, null, null);
+ Table.States (812).Kernel := To_Vector ((0 => (203, 204, 0,
False)));
+ Table.States (812).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 203, 1)));
+ Table.States (813).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (813), (74, 97), (203, 10), 1, null,
null);
+ Table.States (813).Kernel := To_Vector ((0 => (203, 229, 0,
False)));
+ Table.States (813).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 203, 1)));
+ Table.States (814).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (814), (29, 47, 48, 50, 69, 71, 74, 105),
(202, 2), 5,
+ formal_type_declaration_2'Access, null);
+ Table.States (814).Kernel := To_Vector ((0 => (202, 97, 0,
False)));
+ Table.States (814).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 202, 5)));
+ Table.States (815).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (815), 79, 31);
+ Add_Action (Table.States (815), 105, 120);
+ Add_Action (Table.States (815), 106, 34);
+ Add_Action (Table.States (815), 107, 35);
+ Table.States (815).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (815), 129, 42);
+ Add_Goto (Table.States (815), 240, 990);
+ Add_Goto (Table.States (815), 273, 93);
+ Add_Goto (Table.States (815), 294, 98);
+ Table.States (815).Kernel := To_Vector ((0 => (205, 39, 2,
False)));
+ Table.States (815).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
Table.States (816).Action_List.Set_Capacity (1);
- Add_Action (Table.States (816), 96, 990);
- Table.States (816).Kernel := To_Vector ((0 => (222, 32, 1,
False)));
- Table.States (816).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 990)));
- Table.States (817).Action_List.Set_Capacity (23);
- Add_Action (Table.States (817), 4, 1);
- Add_Action (Table.States (817), 5, 2);
- Add_Action (Table.States (817), 13, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (817), 15, 3);
- Add_Action (Table.States (817), 17, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (817), 18, 4);
- Add_Action (Table.States (817), 24, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (817), 27, 5);
- Add_Action (Table.States (817), 28, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (817), 31, 9);
- Add_Action (Table.States (817), 32, 10);
- Add_Action (Table.States (817), 37, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (817), 41, 13);
- Add_Action (Table.States (817), 48, 16);
- Add_Action (Table.States (817), 52, 20);
- Add_Action (Table.States (817), 57, 21);
- Add_Action (Table.States (817), 58, 22);
- Add_Action (Table.States (817), 61, 24);
- Add_Action (Table.States (817), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (817), 93, 31);
- Add_Action (Table.States (817), 104, 360);
- Add_Action (Table.States (817), 105, 33);
- Add_Action (Table.States (817), 106, 34);
- Table.States (817).Goto_List.Set_Capacity (31);
- Add_Goto (Table.States (817), 113, 36);
- Add_Goto (Table.States (817), 123, 38);
- Add_Goto (Table.States (817), 126, 39);
- Add_Goto (Table.States (817), 128, 41);
- Add_Goto (Table.States (817), 131, 42);
- Add_Goto (Table.States (817), 132, 43);
- Add_Goto (Table.States (817), 133, 44);
- Add_Goto (Table.States (817), 139, 47);
- Add_Goto (Table.States (817), 151, 50);
- Add_Goto (Table.States (817), 152, 51);
- Add_Goto (Table.States (817), 161, 53);
- Add_Goto (Table.States (817), 190, 57);
- Add_Goto (Table.States (817), 196, 59);
- Add_Goto (Table.States (817), 217, 68);
- Add_Goto (Table.States (817), 222, 70);
- Add_Goto (Table.States (817), 232, 72);
- Add_Goto (Table.States (817), 239, 73);
- Add_Goto (Table.States (817), 257, 83);
- Add_Goto (Table.States (817), 261, 86);
- Add_Goto (Table.States (817), 272, 92);
- Add_Goto (Table.States (817), 276, 93);
- Add_Goto (Table.States (817), 290, 96);
- Add_Goto (Table.States (817), 293, 97);
- Add_Goto (Table.States (817), 294, 98);
- Add_Goto (Table.States (817), 298, 99);
- Add_Goto (Table.States (817), 299, 361);
- Add_Goto (Table.States (817), 300, 991);
- Add_Goto (Table.States (817), 302, 100);
- Add_Goto (Table.States (817), 303, 101);
- Add_Goto (Table.States (817), 306, 363);
- Add_Goto (Table.States (817), 323, 114);
- Table.States (817).Kernel := To_Vector ((0 => (222, 22, 3,
False)));
- Table.States (817).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 300, 0)));
- end Subr_14;
- procedure Subr_15
- is begin
+ Add_Action (Table.States (816), 97, 991);
+ Table.States (816).Kernel := To_Vector ((0 => (201, 123, 1,
False)));
+ Table.States (816).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 991)));
+ Table.States (817).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (817), 74, 338);
+ Add_Action (Table.States (817), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (817).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (817), 123, 992);
+ Table.States (817).Kernel := To_Vector ((0 => (201, 311, 1,
False)));
+ Table.States (817).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
Table.States (818).Action_List.Set_Capacity (1);
- Add_Action (Table.States (818), 32, 992);
- Table.States (818).Kernel := To_Vector ((0 => (222, 24, 2,
False)));
- Table.States (818).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 32, 992)));
- Table.States (819).Action_List.Set_Capacity (3);
- Add_Action (Table.States (819), (22, 23, 24), (175, 0), 2,
elsif_statement_list_0'Access, null);
- Table.States (819).Kernel := To_Vector ((0 => (175, 174, 0,
True)));
- Table.States (819).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 175, 2)));
- Table.States (819).Minimal_Complete_Actions_Recursive := True;
+ Add_Action (Table.States (818), 97, 993);
+ Table.States (818).Kernel := To_Vector ((0 => (201, 123, 1,
False)));
+ Table.States (818).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 993)));
+ Table.States (819).Action_List.Set_Capacity (15);
+ Add_Action (Table.States (819), 3, 122);
+ Add_Action (Table.States (819), 39, 123);
+ Add_Action (Table.States (819), 40, 124);
+ Add_Action (Table.States (819), 41, 125);
+ Add_Action (Table.States (819), 52, 126);
+ Add_Action (Table.States (819), 74, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (819), 76, 127);
+ Add_Action (Table.States (819), 79, 31);
+ Add_Action (Table.States (819), 95, 128);
+ Add_Action (Table.States (819), 96, 129);
+ Add_Action (Table.States (819), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (819), 104, 130);
+ Add_Action (Table.States (819), 105, 120);
+ Add_Action (Table.States (819), 106, 34);
+ Add_Action (Table.States (819), 107, 35);
+ Table.States (819).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (819), 118, 131);
+ Add_Goto (Table.States (819), 129, 42);
+ Add_Goto (Table.States (819), 192, 132);
+ Add_Goto (Table.States (819), 193, 994);
+ Add_Goto (Table.States (819), 198, 134);
+ Add_Goto (Table.States (819), 240, 135);
+ Add_Goto (Table.States (819), 259, 136);
+ Add_Goto (Table.States (819), 273, 93);
+ Add_Goto (Table.States (819), 276, 137);
+ Add_Goto (Table.States (819), 283, 138);
+ Add_Goto (Table.States (819), 284, 139);
+ Add_Goto (Table.States (819), 285, 140);
+ Add_Goto (Table.States (819), 286, 141);
+ Add_Goto (Table.States (819), 287, 142);
+ Add_Goto (Table.States (819), 288, 143);
+ Add_Goto (Table.States (819), 294, 98);
+ Add_Goto (Table.States (819), 302, 144);
+ Add_Goto (Table.States (819), 321, 145);
+ Add_Goto (Table.States (819), 322, 146);
+ Add_Goto (Table.States (819), 331, 147);
+ Table.States (819).Kernel := To_Vector ((0 => (199, 83, 1,
False)));
+ Table.States (819).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
Table.States (820).Action_List.Set_Capacity (1);
- Add_Action (Table.States (820), 96, 993);
- Table.States (820).Kernel := To_Vector ((0 => (248, 122, 1,
False)));
- Table.States (820).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 993)));
- Table.States (821).Action_List.Set_Capacity (2);
- Add_Action (Table.States (821), 13, 994);
- Add_Action (Table.States (821), 24, 995);
- Table.States (821).Kernel := To_Vector (((247, 159, 3, False),
(247, 159, 2, False)));
- Table.States (821).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 995)));
+ Add_Action (Table.States (820), 97, 995);
+ Table.States (820).Kernel := To_Vector ((0 => (199, 123, 1,
False)));
+ Table.States (820).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 995)));
+ Table.States (821).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (821), 74, 338);
+ Add_Action (Table.States (821), 76, 236);
+ Add_Action (Table.States (821), 83, 996);
+ Add_Action (Table.States (821), 85, 238);
+ Add_Action (Table.States (821), 97, Reduce, (123, 1), 0, null,
null);
+ Add_Action (Table.States (821), 102, 240);
+ Add_Action (Table.States (821), 103, 241);
+ Table.States (821).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (821), 116, 242);
+ Add_Goto (Table.States (821), 123, 997);
+ Add_Goto (Table.States (821), 323, 243);
+ Table.States (821).Kernel := To_Vector (((129, 240, 2, True),
(199, 240, 2, False), (199, 240, 1, False),
+ (240, 240, 5, True), (240, 240, 2, True), (273, 240, 3, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True), (294, 240, 2, True)));
+ Table.States (821).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
Table.States (822).Action_List.Set_Capacity (1);
- Add_Action (Table.States (822), 96, 996);
- Table.States (822).Kernel := To_Vector ((0 => (213, 122, 1,
False)));
- Table.States (822).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 996)));
- Table.States (823).Action_List.Set_Capacity (40);
- Add_Action (Table.States (823), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (250, 0), 6,
- package_renaming_declaration_0'Access, null);
- Table.States (823).Kernel := To_Vector ((0 => (250, 96, 0,
False)));
- Table.States (823).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 250, 6)));
- Table.States (824).Action_List.Set_Capacity (4);
- Add_Action (Table.States (824), 96, Reduce, (240, 1), 0, null,
null);
- Add_Action (Table.States (824), 104, 119);
- Add_Action (Table.States (824), 105, 33);
- Add_Action (Table.States (824), 106, 34);
- Table.States (824).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (824), 128, 41);
- Add_Goto (Table.States (824), 239, 632);
- Add_Goto (Table.States (824), 240, 997);
- Add_Goto (Table.States (824), 272, 92);
- Add_Goto (Table.States (824), 293, 97);
- Table.States (824).Kernel := To_Vector ((0 => (251, 24, 0,
False)));
- Table.States (824).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 240, 0)));
- Table.States (825).Action_List.Set_Capacity (16);
- Add_Action (Table.States (825), 24, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (825), 25, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (825), 28, 183);
- Add_Action (Table.States (825), 29, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (825), 30, 8);
- Add_Action (Table.States (825), 40, 12);
- Add_Action (Table.States (825), 46, 14);
- Add_Action (Table.States (825), 47, 15);
+ Add_Action (Table.States (822), 24, 998);
+ Table.States (822).Kernel := To_Vector ((0 => (223, 301, 3,
False)));
+ Table.States (822).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 998)));
+ Table.States (823).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (823), 68, 999);
+ Table.States (823).Kernel := To_Vector ((0 => (175, 193, 1,
False)));
+ Table.States (823).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 68, 999)));
+ Table.States (824).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (824), 97, 1000);
+ Table.States (824).Kernel := To_Vector ((0 => (223, 32, 1,
False)));
+ Table.States (824).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1000)));
+ Table.States (825).Action_List.Set_Capacity (24);
+ Add_Action (Table.States (825), 4, 1);
+ Add_Action (Table.States (825), 5, 2);
+ Add_Action (Table.States (825), 13, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (825), 15, 3);
+ Add_Action (Table.States (825), 17, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (825), 18, 4);
+ Add_Action (Table.States (825), 24, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (825), 27, 5);
+ Add_Action (Table.States (825), 28, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (825), 31, 9);
+ Add_Action (Table.States (825), 32, 10);
+ Add_Action (Table.States (825), 37, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (825), 41, 13);
Add_Action (Table.States (825), 48, 16);
- Add_Action (Table.States (825), 50, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (825), 51, 19);
- Add_Action (Table.States (825), 63, 25);
- Add_Action (Table.States (825), 66, 26);
- Add_Action (Table.States (825), 69, 27);
- Add_Action (Table.States (825), 71, 28);
- Add_Action (Table.States (825), 104, 185);
- Table.States (825).Goto_List.Set_Capacity (53);
- Add_Goto (Table.States (825), 112, 35);
- Add_Goto (Table.States (825), 121, 37);
+ Add_Action (Table.States (825), 52, 20);
+ Add_Action (Table.States (825), 57, 21);
+ Add_Action (Table.States (825), 58, 22);
+ Add_Action (Table.States (825), 61, 24);
+ Add_Action (Table.States (825), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (825), 79, 31);
+ Add_Action (Table.States (825), 94, 32);
+ Add_Action (Table.States (825), 105, 361);
+ Add_Action (Table.States (825), 106, 34);
+ Add_Action (Table.States (825), 107, 35);
+ Table.States (825).Goto_List.Set_Capacity (31);
+ Add_Goto (Table.States (825), 114, 37);
+ Add_Goto (Table.States (825), 124, 39);
Add_Goto (Table.States (825), 127, 40);
+ Add_Goto (Table.States (825), 129, 42);
+ Add_Goto (Table.States (825), 132, 43);
+ Add_Goto (Table.States (825), 133, 44);
Add_Goto (Table.States (825), 134, 45);
- Add_Goto (Table.States (825), 135, 46);
- Add_Goto (Table.States (825), 157, 391);
- Add_Goto (Table.States (825), 158, 392);
- Add_Goto (Table.States (825), 159, 998);
- Add_Goto (Table.States (825), 179, 54);
- Add_Goto (Table.States (825), 182, 55);
- Add_Goto (Table.States (825), 186, 56);
- Add_Goto (Table.States (825), 193, 58);
- Add_Goto (Table.States (825), 206, 60);
- Add_Goto (Table.States (825), 207, 61);
- Add_Goto (Table.States (825), 209, 62);
- Add_Goto (Table.States (825), 210, 63);
- Add_Goto (Table.States (825), 213, 64);
- Add_Goto (Table.States (825), 214, 65);
- Add_Goto (Table.States (825), 215, 66);
- Add_Goto (Table.States (825), 216, 67);
- Add_Goto (Table.States (825), 219, 69);
+ Add_Goto (Table.States (825), 140, 48);
+ Add_Goto (Table.States (825), 152, 51);
+ Add_Goto (Table.States (825), 153, 52);
+ Add_Goto (Table.States (825), 162, 54);
+ Add_Goto (Table.States (825), 191, 58);
+ Add_Goto (Table.States (825), 197, 60);
+ Add_Goto (Table.States (825), 218, 69);
Add_Goto (Table.States (825), 223, 71);
- Add_Goto (Table.States (825), 243, 74);
- Add_Goto (Table.States (825), 244, 75);
- Add_Goto (Table.States (825), 245, 76);
- Add_Goto (Table.States (825), 246, 77);
- Add_Goto (Table.States (825), 247, 78);
- Add_Goto (Table.States (825), 248, 79);
- Add_Goto (Table.States (825), 249, 80);
- Add_Goto (Table.States (825), 250, 81);
- Add_Goto (Table.States (825), 251, 82);
- Add_Goto (Table.States (825), 257, 394);
- Add_Goto (Table.States (825), 259, 84);
- Add_Goto (Table.States (825), 260, 85);
+ Add_Goto (Table.States (825), 233, 73);
+ Add_Goto (Table.States (825), 240, 74);
+ Add_Goto (Table.States (825), 258, 84);
Add_Goto (Table.States (825), 262, 87);
- Add_Goto (Table.States (825), 263, 88);
- Add_Goto (Table.States (825), 264, 89);
- Add_Goto (Table.States (825), 265, 90);
- Add_Goto (Table.States (825), 271, 91);
- Add_Goto (Table.States (825), 281, 94);
- Add_Goto (Table.States (825), 289, 95);
+ Add_Goto (Table.States (825), 273, 93);
+ Add_Goto (Table.States (825), 277, 94);
+ Add_Goto (Table.States (825), 291, 97);
+ Add_Goto (Table.States (825), 294, 98);
+ Add_Goto (Table.States (825), 295, 99);
+ Add_Goto (Table.States (825), 299, 100);
+ Add_Goto (Table.States (825), 300, 362);
+ Add_Goto (Table.States (825), 301, 1001);
+ Add_Goto (Table.States (825), 303, 101);
Add_Goto (Table.States (825), 304, 102);
- Add_Goto (Table.States (825), 305, 103);
- Add_Goto (Table.States (825), 307, 105);
- Add_Goto (Table.States (825), 308, 106);
- Add_Goto (Table.States (825), 309, 107);
- Add_Goto (Table.States (825), 311, 108);
- Add_Goto (Table.States (825), 313, 109);
- Add_Goto (Table.States (825), 316, 111);
- Add_Goto (Table.States (825), 317, 112);
- Add_Goto (Table.States (825), 319, 113);
- Add_Goto (Table.States (825), 325, 115);
- Add_Goto (Table.States (825), 331, 116);
- Table.States (825).Kernel := To_Vector ((0 => (251, 49, 1,
False)));
- Table.States (825).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 159, 0)));
- Table.States (826).Action_List.Set_Capacity (46);
- Add_Action (Table.States (826), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (257, 0), 6, pragma_g_0'Access, null);
- Table.States (826).Kernel := To_Vector ((0 => (257, 96, 0,
False)));
- Table.States (826).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 257, 6)));
- Table.States (827).Action_List.Set_Capacity (46);
- Add_Action (Table.States (827), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (257, 1), 6, pragma_g_1'Access, null);
- Table.States (827).Kernel := To_Vector ((0 => (257, 96, 0,
False)));
- Table.States (827).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 257, 6)));
+ Add_Goto (Table.States (825), 307, 364);
+ Add_Goto (Table.States (825), 324, 115);
+ Table.States (825).Kernel := To_Vector ((0 => (223, 22, 3,
False)));
+ Table.States (825).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 301, 0)));
+ Table.States (826).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (826), 32, 1002);
+ Table.States (826).Kernel := To_Vector ((0 => (223, 24, 2,
False)));
+ Table.States (826).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 32, 1002)));
+ Table.States (827).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (827), (22, 23, 24), (176, 0), 2,
elsif_statement_list_0'Access, null);
+ Table.States (827).Kernel := To_Vector ((0 => (176, 175, 0,
True)));
+ Table.States (827).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 176, 2)));
+ Table.States (827).Minimal_Complete_Actions_Recursive := True;
Table.States (828).Action_List.Set_Capacity (1);
- Add_Action (Table.States (828), 96, 999);
- Table.States (828).Kernel := To_Vector ((0 => (265, 122, 1,
False)));
- Table.States (828).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 999)));
- Table.States (829).Action_List.Set_Capacity (1);
- Add_Action (Table.States (829), 104, 1000);
- Table.States (829).Kernel := To_Vector ((0 => (176, 25, 6,
False)));
- Table.States (829).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 1000)));
- Table.States (830).Action_List.Set_Capacity (7);
- Add_Action (Table.States (830), (24, 25, 28, 29, 40, 46, 50),
(267, 5), 1, null, null);
- Table.States (830).Kernel := To_Vector ((0 => (267, 121, 0,
False)));
- Table.States (830).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 267, 1)));
- Table.States (831).Action_List.Set_Capacity (7);
- Add_Action (Table.States (831), (24, 25, 28, 29, 40, 46, 50),
(267, 2), 1, null, null);
- Table.States (831).Kernel := To_Vector ((0 => (267, 176, 0,
False)));
- Table.States (831).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 267, 1)));
- Table.States (832).Action_List.Set_Capacity (7);
- Add_Action (Table.States (832), (24, 25, 28, 29, 40, 46, 50),
(267, 3), 1, null, null);
- Table.States (832).Kernel := To_Vector ((0 => (267, 193, 0,
False)));
- Table.States (832).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 267, 1)));
- Table.States (833).Action_List.Set_Capacity (7);
- Add_Action (Table.States (833), (24, 25, 28, 29, 40, 46, 50),
(267, 4), 1, null, null);
- Table.States (833).Kernel := To_Vector ((0 => (267, 243, 0,
False)));
- Table.States (833).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 267, 1)));
- Table.States (834).Action_List.Set_Capacity (2);
- Add_Action (Table.States (834), 29, 7);
- Add_Action (Table.States (834), 50, 18);
- Table.States (834).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (834), 207, 246);
- Add_Goto (Table.States (834), 262, 247);
- Add_Goto (Table.States (834), 312, 1001);
- Table.States (834).Kernel := To_Vector (((193, 246, 7, False),
(243, 246, 5, False), (307, 246, 6, False),
- (309, 246, 3, False)));
- Table.States (834).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 50, 18)));
- Table.States (835).Action_List.Set_Capacity (7);
- Add_Action (Table.States (835), (24, 25, 28, 29, 40, 46, 50),
(268, 1), 1, null, null);
- Table.States (835).Kernel := To_Vector ((0 => (268, 267, 0,
False)));
- Table.States (835).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 268, 1)));
- Table.States (836).Action_List.Set_Capacity (7);
- Add_Action (Table.States (836), 24, Reduce, (269, 0), 1, null,
null);
- Add_Action (Table.States (836), 25, 829);
- Add_Action (Table.States (836), 28, 183);
- Add_Action (Table.States (836), 29, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (836), 40, 12);
- Add_Action (Table.States (836), 46, 14);
- Add_Action (Table.States (836), 50, Reduce, (246, 2), 0, null,
null);
- Table.States (836).Goto_List.Set_Capacity (13);
- Add_Goto (Table.States (836), 121, 830);
- Add_Goto (Table.States (836), 127, 40);
- Add_Goto (Table.States (836), 176, 831);
- Add_Goto (Table.States (836), 182, 55);
- Add_Goto (Table.States (836), 193, 832);
- Add_Goto (Table.States (836), 207, 61);
- Add_Goto (Table.States (836), 243, 833);
- Add_Goto (Table.States (836), 246, 834);
- Add_Goto (Table.States (836), 262, 87);
- Add_Goto (Table.States (836), 267, 1002);
- Add_Goto (Table.States (836), 281, 94);
- Add_Goto (Table.States (836), 307, 838);
- Add_Goto (Table.States (836), 309, 839);
- Table.States (836).Kernel := To_Vector (((268, 268, 3, True),
(269, 268, 0, False)));
- Table.States (836).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 269, 1)));
+ Add_Action (Table.States (828), 97, 1003);
+ Table.States (828).Kernel := To_Vector ((0 => (249, 123, 1,
False)));
+ Table.States (828).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1003)));
+ Table.States (829).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (829), 13, 1004);
+ Add_Action (Table.States (829), 24, 1005);
+ Table.States (829).Kernel := To_Vector (((248, 160, 3, False),
(248, 160, 2, False)));
+ Table.States (829).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1005)));
+ Table.States (830).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (830), 97, 1006);
+ Table.States (830).Kernel := To_Vector ((0 => (214, 123, 1,
False)));
+ Table.States (830).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1006)));
+ Table.States (831).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (831), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (251, 0), 6,
+ package_renaming_declaration_0'Access, null);
+ Table.States (831).Kernel := To_Vector ((0 => (251, 97, 0,
False)));
+ Table.States (831).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 251, 6)));
+ Table.States (832).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (832), 79, 31);
+ Add_Action (Table.States (832), 97, Reduce, (241, 1), 0, null,
null);
+ Add_Action (Table.States (832), 105, 120);
+ Add_Action (Table.States (832), 106, 34);
+ Add_Action (Table.States (832), 107, 35);
+ Table.States (832).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (832), 129, 42);
+ Add_Goto (Table.States (832), 240, 638);
+ Add_Goto (Table.States (832), 241, 1007);
+ Add_Goto (Table.States (832), 273, 93);
+ Add_Goto (Table.States (832), 294, 98);
+ Table.States (832).Kernel := To_Vector ((0 => (252, 24, 0,
False)));
+ Table.States (832).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 241, 0)));
+ Table.States (833).Action_List.Set_Capacity (16);
+ Add_Action (Table.States (833), 24, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (833), 25, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (833), 28, 184);
+ Add_Action (Table.States (833), 29, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (833), 30, 8);
+ Add_Action (Table.States (833), 40, 12);
+ Add_Action (Table.States (833), 46, 14);
+ Add_Action (Table.States (833), 47, 15);
+ Add_Action (Table.States (833), 48, 16);
+ Add_Action (Table.States (833), 50, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (833), 51, 19);
+ Add_Action (Table.States (833), 63, 25);
+ Add_Action (Table.States (833), 66, 26);
+ Add_Action (Table.States (833), 69, 27);
+ Add_Action (Table.States (833), 71, 28);
+ Add_Action (Table.States (833), 105, 186);
+ Table.States (833).Goto_List.Set_Capacity (53);
+ Add_Goto (Table.States (833), 113, 36);
+ Add_Goto (Table.States (833), 122, 38);
+ Add_Goto (Table.States (833), 128, 41);
+ Add_Goto (Table.States (833), 135, 46);
+ Add_Goto (Table.States (833), 136, 47);
+ Add_Goto (Table.States (833), 158, 392);
+ Add_Goto (Table.States (833), 159, 393);
+ Add_Goto (Table.States (833), 160, 1008);
+ Add_Goto (Table.States (833), 180, 55);
+ Add_Goto (Table.States (833), 183, 56);
+ Add_Goto (Table.States (833), 187, 57);
+ Add_Goto (Table.States (833), 194, 59);
+ Add_Goto (Table.States (833), 207, 61);
+ Add_Goto (Table.States (833), 208, 62);
+ Add_Goto (Table.States (833), 210, 63);
+ Add_Goto (Table.States (833), 211, 64);
+ Add_Goto (Table.States (833), 214, 65);
+ Add_Goto (Table.States (833), 215, 66);
+ Add_Goto (Table.States (833), 216, 67);
+ Add_Goto (Table.States (833), 217, 68);
+ Add_Goto (Table.States (833), 220, 70);
+ Add_Goto (Table.States (833), 224, 72);
+ Add_Goto (Table.States (833), 244, 75);
+ Add_Goto (Table.States (833), 245, 76);
+ Add_Goto (Table.States (833), 246, 77);
+ Add_Goto (Table.States (833), 247, 78);
+ Add_Goto (Table.States (833), 248, 79);
+ Add_Goto (Table.States (833), 249, 80);
+ Add_Goto (Table.States (833), 250, 81);
+ Add_Goto (Table.States (833), 251, 82);
+ Add_Goto (Table.States (833), 252, 83);
+ Add_Goto (Table.States (833), 258, 395);
+ Add_Goto (Table.States (833), 260, 85);
+ Add_Goto (Table.States (833), 261, 86);
+ Add_Goto (Table.States (833), 263, 88);
+ Add_Goto (Table.States (833), 264, 89);
+ Add_Goto (Table.States (833), 265, 90);
+ Add_Goto (Table.States (833), 266, 91);
+ Add_Goto (Table.States (833), 272, 92);
+ Add_Goto (Table.States (833), 282, 95);
+ Add_Goto (Table.States (833), 290, 96);
+ Add_Goto (Table.States (833), 305, 103);
+ Add_Goto (Table.States (833), 306, 104);
+ Add_Goto (Table.States (833), 308, 106);
+ Add_Goto (Table.States (833), 309, 107);
+ Add_Goto (Table.States (833), 310, 108);
+ Add_Goto (Table.States (833), 312, 109);
+ Add_Goto (Table.States (833), 314, 110);
+ Add_Goto (Table.States (833), 317, 112);
+ Add_Goto (Table.States (833), 318, 113);
+ Add_Goto (Table.States (833), 320, 114);
+ Add_Goto (Table.States (833), 326, 116);
+ Add_Goto (Table.States (833), 332, 117);
+ Table.States (833).Kernel := To_Vector ((0 => (252, 49, 1,
False)));
+ Table.States (833).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 160, 0)));
+ Table.States (834).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (834), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (258, 0), 6, pragma_g_0'Access, null);
+ Table.States (834).Kernel := To_Vector ((0 => (258, 97, 0,
False)));
+ Table.States (834).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 258, 6)));
+ Table.States (835).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (835), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (258, 1), 6, pragma_g_1'Access, null);
+ Table.States (835).Kernel := To_Vector ((0 => (258, 97, 0,
False)));
+ Table.States (835).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 258, 6)));
+ Table.States (836).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (836), 97, 1009);
+ Table.States (836).Kernel := To_Vector ((0 => (266, 123, 1,
False)));
+ Table.States (836).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1009)));
Table.States (837).Action_List.Set_Capacity (1);
- Add_Action (Table.States (837), 24, 1003);
- Table.States (837).Kernel := To_Vector ((0 => (264, 269, 2,
False)));
- Table.States (837).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1003)));
+ Add_Action (Table.States (837), 105, 1010);
+ Table.States (837).Kernel := To_Vector ((0 => (177, 25, 6,
False)));
+ Table.States (837).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 1010)));
Table.States (838).Action_List.Set_Capacity (7);
- Add_Action (Table.States (838), (24, 25, 28, 29, 40, 46, 50),
(267, 1), 1, null, null);
- Table.States (838).Kernel := To_Vector ((0 => (267, 307, 0,
False)));
- Table.States (838).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 267, 1)));
+ Add_Action (Table.States (838), (24, 25, 28, 29, 40, 46, 50),
(268, 5), 1, null, null);
+ Table.States (838).Kernel := To_Vector ((0 => (268, 122, 0,
False)));
+ Table.States (838).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 268, 1)));
Table.States (839).Action_List.Set_Capacity (7);
- Add_Action (Table.States (839), (24, 25, 28, 29, 40, 46, 50),
(267, 0), 1, null, null);
- Table.States (839).Kernel := To_Vector ((0 => (267, 309, 0,
False)));
- Table.States (839).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 267, 1)));
- Table.States (840).Action_List.Set_Capacity (18);
- Add_Action (Table.States (840), 24, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (840), 25, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (840), 28, 183);
- Add_Action (Table.States (840), 29, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (840), 30, 8);
- Add_Action (Table.States (840), 39, 1004);
- Add_Action (Table.States (840), 40, 12);
- Add_Action (Table.States (840), 46, 14);
- Add_Action (Table.States (840), 47, 15);
- Add_Action (Table.States (840), 48, 16);
- Add_Action (Table.States (840), 49, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (840), 50, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (840), 51, 19);
- Add_Action (Table.States (840), 63, 25);
- Add_Action (Table.States (840), 66, 26);
- Add_Action (Table.States (840), 69, 27);
- Add_Action (Table.States (840), 71, 28);
- Add_Action (Table.States (840), 104, 185);
- Table.States (840).Goto_List.Set_Capacity (54);
- Add_Goto (Table.States (840), 112, 35);
- Add_Goto (Table.States (840), 121, 37);
- Add_Goto (Table.States (840), 127, 40);
- Add_Goto (Table.States (840), 134, 45);
- Add_Goto (Table.States (840), 135, 46);
- Add_Goto (Table.States (840), 157, 391);
- Add_Goto (Table.States (840), 158, 392);
- Add_Goto (Table.States (840), 159, 669);
- Add_Goto (Table.States (840), 179, 54);
- Add_Goto (Table.States (840), 182, 55);
- Add_Goto (Table.States (840), 186, 56);
- Add_Goto (Table.States (840), 193, 58);
- Add_Goto (Table.States (840), 206, 60);
- Add_Goto (Table.States (840), 207, 61);
- Add_Goto (Table.States (840), 209, 62);
- Add_Goto (Table.States (840), 210, 63);
- Add_Goto (Table.States (840), 213, 64);
- Add_Goto (Table.States (840), 214, 65);
- Add_Goto (Table.States (840), 215, 66);
- Add_Goto (Table.States (840), 216, 67);
- Add_Goto (Table.States (840), 219, 69);
- Add_Goto (Table.States (840), 223, 71);
- Add_Goto (Table.States (840), 243, 74);
- Add_Goto (Table.States (840), 244, 75);
- Add_Goto (Table.States (840), 245, 76);
- Add_Goto (Table.States (840), 246, 77);
- Add_Goto (Table.States (840), 247, 78);
- Add_Goto (Table.States (840), 248, 79);
- Add_Goto (Table.States (840), 249, 80);
- Add_Goto (Table.States (840), 250, 81);
- Add_Goto (Table.States (840), 251, 82);
- Add_Goto (Table.States (840), 257, 394);
- Add_Goto (Table.States (840), 259, 84);
- Add_Goto (Table.States (840), 260, 85);
- Add_Goto (Table.States (840), 262, 87);
- Add_Goto (Table.States (840), 263, 88);
- Add_Goto (Table.States (840), 264, 89);
- Add_Goto (Table.States (840), 265, 90);
- Add_Goto (Table.States (840), 266, 1005);
- Add_Goto (Table.States (840), 271, 91);
- Add_Goto (Table.States (840), 281, 94);
- Add_Goto (Table.States (840), 289, 95);
- Add_Goto (Table.States (840), 304, 102);
- Add_Goto (Table.States (840), 305, 103);
- Add_Goto (Table.States (840), 307, 105);
- Add_Goto (Table.States (840), 308, 106);
- Add_Goto (Table.States (840), 309, 107);
- Add_Goto (Table.States (840), 311, 108);
- Add_Goto (Table.States (840), 313, 109);
- Add_Goto (Table.States (840), 316, 111);
- Add_Goto (Table.States (840), 317, 112);
- Add_Goto (Table.States (840), 319, 113);
- Add_Goto (Table.States (840), 325, 115);
- Add_Goto (Table.States (840), 331, 116);
- Table.States (840).Kernel := To_Vector (((271, 35, 5, False),
(271, 35, 2, False)));
- Table.States (840).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 159, 0)));
- Table.States (841).Action_List.Set_Capacity (2);
- Add_Action (Table.States (841), 10, 1006);
- Add_Action (Table.States (841), 74, 1007);
- Table.States (841).Kernel := To_Vector (((227, 227, 2, True),
(304, 227, 3, False)));
- Table.States (841).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 74, 1007)));
- Table.States (842).Action_List.Set_Capacity (7);
- Add_Action (Table.States (842), 10, Reduce, (227, 1), 1,
interface_list_1'Access, null);
- Add_Action (Table.States (842), 74, Reduce, (227, 1), 1,
interface_list_1'Access, null);
- Add_Action (Table.States (842), 76, 235);
- Add_Action (Table.States (842), 84, 237);
- Add_Action (Table.States (842), 96, Reduce, (227, 1), 1,
interface_list_1'Access, null);
- Add_Action (Table.States (842), 101, 239);
- Add_Action (Table.States (842), 102, 240);
- Table.States (842).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (842), 115, 241);
- Add_Goto (Table.States (842), 322, 242);
- Table.States (842).Kernel := To_Vector (((128, 239, 2, True),
(227, 239, 0, False), (239, 239, 5, True),
- (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (842).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 227, 1)));
- Table.States (843).Action_List.Set_Capacity (2);
- Add_Action (Table.States (843), 96, Reduce, (220, 1), 0, null,
null);
- Add_Action (Table.States (843), 104, 149);
- Table.States (843).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (843), 220, 1008);
- Table.States (843).Kernel := To_Vector ((0 => (266, 24, 0,
False)));
- Table.States (843).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 220, 0)));
- Table.States (844).Action_List.Set_Capacity (16);
- Add_Action (Table.States (844), 24, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (844), 25, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (844), 28, 183);
- Add_Action (Table.States (844), 29, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (844), 30, 8);
+ Add_Action (Table.States (839), (24, 25, 28, 29, 40, 46, 50),
(268, 2), 1, null, null);
+ Table.States (839).Kernel := To_Vector ((0 => (268, 177, 0,
False)));
+ Table.States (839).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 268, 1)));
+ Table.States (840).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (840), (24, 25, 28, 29, 40, 46, 50),
(268, 3), 1, null, null);
+ Table.States (840).Kernel := To_Vector ((0 => (268, 194, 0,
False)));
+ Table.States (840).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 268, 1)));
+ Table.States (841).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (841), (24, 25, 28, 29, 40, 46, 50),
(268, 4), 1, null, null);
+ Table.States (841).Kernel := To_Vector ((0 => (268, 244, 0,
False)));
+ Table.States (841).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 268, 1)));
+ Table.States (842).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (842), 29, 7);
+ Add_Action (Table.States (842), 50, 18);
+ Table.States (842).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (842), 208, 247);
+ Add_Goto (Table.States (842), 263, 248);
+ Add_Goto (Table.States (842), 313, 1011);
+ Table.States (842).Kernel := To_Vector (((194, 247, 7, False),
(244, 247, 5, False), (308, 247, 6, False),
+ (310, 247, 3, False)));
+ Table.States (842).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 50, 18)));
+ Table.States (843).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (843), (24, 25, 28, 29, 40, 46, 50),
(269, 1), 1, null, null);
+ Table.States (843).Kernel := To_Vector ((0 => (269, 268, 0,
False)));
+ Table.States (843).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 269, 1)));
+ Table.States (844).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (844), 24, Reduce, (270, 0), 1, null,
null);
+ Add_Action (Table.States (844), 25, 837);
+ Add_Action (Table.States (844), 28, 184);
+ Add_Action (Table.States (844), 29, Reduce, (247, 2), 0, null,
null);
Add_Action (Table.States (844), 40, 12);
Add_Action (Table.States (844), 46, 14);
- Add_Action (Table.States (844), 47, 15);
- Add_Action (Table.States (844), 48, 16);
- Add_Action (Table.States (844), 50, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (844), 51, 19);
- Add_Action (Table.States (844), 63, 25);
- Add_Action (Table.States (844), 66, 26);
- Add_Action (Table.States (844), 69, 27);
- Add_Action (Table.States (844), 71, 28);
- Add_Action (Table.States (844), 104, 185);
- Table.States (844).Goto_List.Set_Capacity (53);
- Add_Goto (Table.States (844), 112, 35);
- Add_Goto (Table.States (844), 121, 37);
- Add_Goto (Table.States (844), 127, 40);
- Add_Goto (Table.States (844), 134, 45);
- Add_Goto (Table.States (844), 135, 46);
- Add_Goto (Table.States (844), 157, 391);
- Add_Goto (Table.States (844), 158, 392);
- Add_Goto (Table.States (844), 159, 1009);
- Add_Goto (Table.States (844), 179, 54);
- Add_Goto (Table.States (844), 182, 55);
- Add_Goto (Table.States (844), 186, 56);
- Add_Goto (Table.States (844), 193, 58);
- Add_Goto (Table.States (844), 206, 60);
- Add_Goto (Table.States (844), 207, 61);
- Add_Goto (Table.States (844), 209, 62);
- Add_Goto (Table.States (844), 210, 63);
- Add_Goto (Table.States (844), 213, 64);
- Add_Goto (Table.States (844), 214, 65);
- Add_Goto (Table.States (844), 215, 66);
- Add_Goto (Table.States (844), 216, 67);
- Add_Goto (Table.States (844), 219, 69);
- Add_Goto (Table.States (844), 223, 71);
- Add_Goto (Table.States (844), 243, 74);
- Add_Goto (Table.States (844), 244, 75);
- Add_Goto (Table.States (844), 245, 76);
- Add_Goto (Table.States (844), 246, 77);
- Add_Goto (Table.States (844), 247, 78);
- Add_Goto (Table.States (844), 248, 79);
- Add_Goto (Table.States (844), 249, 80);
- Add_Goto (Table.States (844), 250, 81);
- Add_Goto (Table.States (844), 251, 82);
- Add_Goto (Table.States (844), 257, 394);
- Add_Goto (Table.States (844), 259, 84);
- Add_Goto (Table.States (844), 260, 85);
- Add_Goto (Table.States (844), 262, 87);
+ Add_Action (Table.States (844), 50, Reduce, (247, 2), 0, null,
null);
+ Table.States (844).Goto_List.Set_Capacity (13);
+ Add_Goto (Table.States (844), 122, 838);
+ Add_Goto (Table.States (844), 128, 41);
+ Add_Goto (Table.States (844), 177, 839);
+ Add_Goto (Table.States (844), 183, 56);
+ Add_Goto (Table.States (844), 194, 840);
+ Add_Goto (Table.States (844), 208, 62);
+ Add_Goto (Table.States (844), 244, 841);
+ Add_Goto (Table.States (844), 247, 842);
Add_Goto (Table.States (844), 263, 88);
- Add_Goto (Table.States (844), 264, 89);
- Add_Goto (Table.States (844), 265, 90);
- Add_Goto (Table.States (844), 271, 91);
- Add_Goto (Table.States (844), 281, 94);
- Add_Goto (Table.States (844), 289, 95);
- Add_Goto (Table.States (844), 304, 102);
- Add_Goto (Table.States (844), 305, 103);
- Add_Goto (Table.States (844), 307, 105);
- Add_Goto (Table.States (844), 308, 106);
- Add_Goto (Table.States (844), 309, 107);
- Add_Goto (Table.States (844), 311, 108);
- Add_Goto (Table.States (844), 313, 109);
- Add_Goto (Table.States (844), 316, 111);
- Add_Goto (Table.States (844), 317, 112);
- Add_Goto (Table.States (844), 319, 113);
- Add_Goto (Table.States (844), 325, 115);
- Add_Goto (Table.States (844), 331, 116);
- Table.States (844).Kernel := To_Vector ((0 => (266, 49, 1,
False)));
- Table.States (844).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 159, 0)));
- Table.States (845).Action_List.Set_Capacity (40);
- Add_Action (Table.States (845), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (304, 1), 6,
+ Add_Goto (Table.States (844), 268, 1012);
+ Add_Goto (Table.States (844), 282, 95);
+ Add_Goto (Table.States (844), 308, 846);
+ Add_Goto (Table.States (844), 310, 847);
+ Table.States (844).Kernel := To_Vector (((269, 269, 3, True),
(270, 269, 0, False)));
+ Table.States (844).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 270, 1)));
+ Table.States (845).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (845), 24, 1013);
+ Table.States (845).Kernel := To_Vector ((0 => (265, 270, 2,
False)));
+ Table.States (845).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1013)));
+ Table.States (846).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (846), (24, 25, 28, 29, 40, 46, 50),
(268, 1), 1, null, null);
+ Table.States (846).Kernel := To_Vector ((0 => (268, 308, 0,
False)));
+ Table.States (846).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 268, 1)));
+ Table.States (847).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (847), (24, 25, 28, 29, 40, 46, 50),
(268, 0), 1, null, null);
+ Table.States (847).Kernel := To_Vector ((0 => (268, 310, 0,
False)));
+ Table.States (847).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 268, 1)));
+ Table.States (848).Action_List.Set_Capacity (18);
+ Add_Action (Table.States (848), 24, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (848), 25, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (848), 28, 184);
+ Add_Action (Table.States (848), 29, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (848), 30, 8);
+ Add_Action (Table.States (848), 39, 1014);
+ Add_Action (Table.States (848), 40, 12);
+ Add_Action (Table.States (848), 46, 14);
+ Add_Action (Table.States (848), 47, 15);
+ Add_Action (Table.States (848), 48, 16);
+ Add_Action (Table.States (848), 49, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (848), 50, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (848), 51, 19);
+ Add_Action (Table.States (848), 63, 25);
+ Add_Action (Table.States (848), 66, 26);
+ Add_Action (Table.States (848), 69, 27);
+ Add_Action (Table.States (848), 71, 28);
+ Add_Action (Table.States (848), 105, 186);
+ Table.States (848).Goto_List.Set_Capacity (54);
+ Add_Goto (Table.States (848), 113, 36);
+ Add_Goto (Table.States (848), 122, 38);
+ Add_Goto (Table.States (848), 128, 41);
+ Add_Goto (Table.States (848), 135, 46);
+ Add_Goto (Table.States (848), 136, 47);
+ Add_Goto (Table.States (848), 158, 392);
+ Add_Goto (Table.States (848), 159, 393);
+ Add_Goto (Table.States (848), 160, 675);
+ Add_Goto (Table.States (848), 180, 55);
+ Add_Goto (Table.States (848), 183, 56);
+ Add_Goto (Table.States (848), 187, 57);
+ Add_Goto (Table.States (848), 194, 59);
+ Add_Goto (Table.States (848), 207, 61);
+ Add_Goto (Table.States (848), 208, 62);
+ Add_Goto (Table.States (848), 210, 63);
+ Add_Goto (Table.States (848), 211, 64);
+ Add_Goto (Table.States (848), 214, 65);
+ Add_Goto (Table.States (848), 215, 66);
+ Add_Goto (Table.States (848), 216, 67);
+ Add_Goto (Table.States (848), 217, 68);
+ Add_Goto (Table.States (848), 220, 70);
+ Add_Goto (Table.States (848), 224, 72);
+ Add_Goto (Table.States (848), 244, 75);
+ Add_Goto (Table.States (848), 245, 76);
+ Add_Goto (Table.States (848), 246, 77);
+ Add_Goto (Table.States (848), 247, 78);
+ Add_Goto (Table.States (848), 248, 79);
+ Add_Goto (Table.States (848), 249, 80);
+ Add_Goto (Table.States (848), 250, 81);
+ Add_Goto (Table.States (848), 251, 82);
+ Add_Goto (Table.States (848), 252, 83);
+ Add_Goto (Table.States (848), 258, 395);
+ Add_Goto (Table.States (848), 260, 85);
+ Add_Goto (Table.States (848), 261, 86);
+ Add_Goto (Table.States (848), 263, 88);
+ Add_Goto (Table.States (848), 264, 89);
+ Add_Goto (Table.States (848), 265, 90);
+ Add_Goto (Table.States (848), 266, 91);
+ Add_Goto (Table.States (848), 267, 1015);
+ Add_Goto (Table.States (848), 272, 92);
+ Add_Goto (Table.States (848), 282, 95);
+ Add_Goto (Table.States (848), 290, 96);
+ Add_Goto (Table.States (848), 305, 103);
+ Add_Goto (Table.States (848), 306, 104);
+ Add_Goto (Table.States (848), 308, 106);
+ Add_Goto (Table.States (848), 309, 107);
+ Add_Goto (Table.States (848), 310, 108);
+ Add_Goto (Table.States (848), 312, 109);
+ Add_Goto (Table.States (848), 314, 110);
+ Add_Goto (Table.States (848), 317, 112);
+ Add_Goto (Table.States (848), 318, 113);
+ Add_Goto (Table.States (848), 320, 114);
+ Add_Goto (Table.States (848), 326, 116);
+ Add_Goto (Table.States (848), 332, 117);
+ Table.States (848).Kernel := To_Vector (((272, 35, 5, False),
(272, 35, 2, False)));
+ Table.States (848).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 160, 0)));
+ Table.States (849).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (849), 10, 1016);
+ Add_Action (Table.States (849), 74, 1017);
+ Table.States (849).Kernel := To_Vector (((228, 228, 2, True),
(305, 228, 3, False)));
+ Table.States (849).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 74, 1017)));
+ Table.States (850).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (850), 10, Reduce, (228, 1), 1,
interface_list_1'Access, null);
+ Add_Action (Table.States (850), 74, Reduce, (228, 1), 1,
interface_list_1'Access, null);
+ Add_Action (Table.States (850), 76, 236);
+ Add_Action (Table.States (850), 85, 238);
+ Add_Action (Table.States (850), 97, Reduce, (228, 1), 1,
interface_list_1'Access, null);
+ Add_Action (Table.States (850), 102, 240);
+ Add_Action (Table.States (850), 103, 241);
+ Table.States (850).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (850), 116, 242);
+ Add_Goto (Table.States (850), 323, 243);
+ Table.States (850).Kernel := To_Vector (((129, 240, 2, True),
(228, 240, 0, False), (240, 240, 5, True),
+ (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (850).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 228, 1)));
+ Table.States (851).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (851), 97, Reduce, (221, 1), 0, null,
null);
+ Add_Action (Table.States (851), 105, 150);
+ Table.States (851).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (851), 221, 1018);
+ Table.States (851).Kernel := To_Vector ((0 => (267, 24, 0,
False)));
+ Table.States (851).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 221, 0)));
+ Table.States (852).Action_List.Set_Capacity (16);
+ Add_Action (Table.States (852), 24, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (852), 25, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (852), 28, 184);
+ Add_Action (Table.States (852), 29, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (852), 30, 8);
+ Add_Action (Table.States (852), 40, 12);
+ Add_Action (Table.States (852), 46, 14);
+ Add_Action (Table.States (852), 47, 15);
+ Add_Action (Table.States (852), 48, 16);
+ Add_Action (Table.States (852), 50, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (852), 51, 19);
+ Add_Action (Table.States (852), 63, 25);
+ Add_Action (Table.States (852), 66, 26);
+ Add_Action (Table.States (852), 69, 27);
+ Add_Action (Table.States (852), 71, 28);
+ Add_Action (Table.States (852), 105, 186);
+ Table.States (852).Goto_List.Set_Capacity (53);
+ Add_Goto (Table.States (852), 113, 36);
+ Add_Goto (Table.States (852), 122, 38);
+ Add_Goto (Table.States (852), 128, 41);
+ Add_Goto (Table.States (852), 135, 46);
+ Add_Goto (Table.States (852), 136, 47);
+ Add_Goto (Table.States (852), 158, 392);
+ Add_Goto (Table.States (852), 159, 393);
+ Add_Goto (Table.States (852), 160, 1019);
+ Add_Goto (Table.States (852), 180, 55);
+ Add_Goto (Table.States (852), 183, 56);
+ Add_Goto (Table.States (852), 187, 57);
+ Add_Goto (Table.States (852), 194, 59);
+ Add_Goto (Table.States (852), 207, 61);
+ Add_Goto (Table.States (852), 208, 62);
+ Add_Goto (Table.States (852), 210, 63);
+ Add_Goto (Table.States (852), 211, 64);
+ Add_Goto (Table.States (852), 214, 65);
+ Add_Goto (Table.States (852), 215, 66);
+ Add_Goto (Table.States (852), 216, 67);
+ Add_Goto (Table.States (852), 217, 68);
+ Add_Goto (Table.States (852), 220, 70);
+ Add_Goto (Table.States (852), 224, 72);
+ Add_Goto (Table.States (852), 244, 75);
+ Add_Goto (Table.States (852), 245, 76);
+ Add_Goto (Table.States (852), 246, 77);
+ Add_Goto (Table.States (852), 247, 78);
+ Add_Goto (Table.States (852), 248, 79);
+ Add_Goto (Table.States (852), 249, 80);
+ Add_Goto (Table.States (852), 250, 81);
+ Add_Goto (Table.States (852), 251, 82);
+ Add_Goto (Table.States (852), 252, 83);
+ Add_Goto (Table.States (852), 258, 395);
+ Add_Goto (Table.States (852), 260, 85);
+ Add_Goto (Table.States (852), 261, 86);
+ Add_Goto (Table.States (852), 263, 88);
+ Add_Goto (Table.States (852), 264, 89);
+ Add_Goto (Table.States (852), 265, 90);
+ Add_Goto (Table.States (852), 266, 91);
+ Add_Goto (Table.States (852), 272, 92);
+ Add_Goto (Table.States (852), 282, 95);
+ Add_Goto (Table.States (852), 290, 96);
+ Add_Goto (Table.States (852), 305, 103);
+ Add_Goto (Table.States (852), 306, 104);
+ Add_Goto (Table.States (852), 308, 106);
+ Add_Goto (Table.States (852), 309, 107);
+ Add_Goto (Table.States (852), 310, 108);
+ Add_Goto (Table.States (852), 312, 109);
+ Add_Goto (Table.States (852), 314, 110);
+ Add_Goto (Table.States (852), 317, 112);
+ Add_Goto (Table.States (852), 318, 113);
+ Add_Goto (Table.States (852), 320, 114);
+ Add_Goto (Table.States (852), 326, 116);
+ Add_Goto (Table.States (852), 332, 117);
+ Table.States (852).Kernel := To_Vector ((0 => (267, 49, 1,
False)));
+ Table.States (852).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 160, 0)));
+ end Subr_15;
+ procedure Subr_16
+ is begin
+ Table.States (853).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (853), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (305, 1), 6,
single_protected_declaration_1'Access,
single_protected_declaration_1_check'Access);
- Table.States (845).Kernel := To_Vector ((0 => (304, 96, 0,
False)));
- Table.States (845).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 304, 6)));
- Table.States (846).Action_List.Set_Capacity (3);
- Add_Action (Table.States (846), (21, 82, 96), (292, 1), 1, null,
null);
- Table.States (846).Kernel := To_Vector ((0 => (292, 114, 0,
False)));
- Table.States (846).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 292, 1)));
- Table.States (847).Action_List.Set_Capacity (3);
- Add_Action (Table.States (847), 21, Reduce, (194, 1), 5,
extended_return_object_declaration_1'Access,
- null);
- Add_Action (Table.States (847), 82, 1010);
- Add_Action (Table.States (847), 96, Reduce, (194, 1), 5,
extended_return_object_declaration_1'Access,
- null);
- Table.States (847).Kernel := To_Vector (((194, 292, 1, False),
(194, 292, 0, False)));
- Table.States (847).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 194, 5)));
- Table.States (848).Action_List.Set_Capacity (3);
- Add_Action (Table.States (848), (21, 82, 96), (292, 0), 1, null,
null);
- Table.States (848).Kernel := To_Vector ((0 => (292, 314, 0,
False)));
- Table.States (848).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 292, 1)));
- Table.States (849).Action_List.Set_Capacity (1);
- Add_Action (Table.States (849), 96, 1011);
- Table.States (849).Kernel := To_Vector ((0 => (196, 58, 1,
False)));
- Table.States (849).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1011)));
- Table.States (850).Action_List.Set_Capacity (3);
- Add_Action (Table.States (850), 104, 119);
- Add_Action (Table.States (850), 105, 33);
- Add_Action (Table.States (850), 106, 34);
- Table.States (850).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (850), 128, 41);
- Add_Goto (Table.States (850), 239, 1012);
- Add_Goto (Table.States (850), 272, 92);
- Add_Goto (Table.States (850), 293, 97);
- Table.States (850).Kernel := To_Vector (((247, 14, 5, False),
(247, 14, 4, False)));
- Table.States (850).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (851).Action_List.Set_Capacity (1);
- Add_Action (Table.States (851), 104, 1013);
- Table.States (851).Kernel := To_Vector ((0 => (264, 14, 4,
False)));
- Table.States (851).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 1013)));
- Table.States (852).Action_List.Set_Capacity (1);
- Add_Action (Table.States (852), 104, 1014);
- Table.States (852).Kernel := To_Vector ((0 => (316, 14, 5,
False)));
- Table.States (852).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 1014)));
- Table.States (853).Action_List.Set_Capacity (2);
- Add_Action (Table.States (853), 35, Reduce, (122, 1), 0, null,
null);
- Add_Action (Table.States (853), 74, 337);
- Table.States (853).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (853), 122, 1015);
- Table.States (853).Kernel := To_Vector ((0 => (307, 312, 4,
False)));
- Table.States (853).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
+ Table.States (853).Kernel := To_Vector ((0 => (305, 97, 0,
False)));
+ Table.States (853).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 305, 6)));
Table.States (854).Action_List.Set_Capacity (3);
- Add_Action (Table.States (854), (22, 24, 43), (295, 1), 5,
select_alternative_1'Access, null);
- Table.States (854).Kernel := To_Vector ((0 => (295, 96, 0,
False)));
- Table.States (854).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 295, 5)));
+ Add_Action (Table.States (854), (21, 83, 97), (293, 1), 1, null,
null);
+ Table.States (854).Kernel := To_Vector ((0 => (293, 115, 0,
False)));
+ Table.States (854).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 293, 1)));
Table.States (855).Action_List.Set_Capacity (3);
- Add_Action (Table.States (855), (22, 24, 43), (295, 0), 5,
select_alternative_0'Access, null);
- Table.States (855).Kernel := To_Vector ((0 => (295, 300, 0,
False)));
- Table.States (855).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 295, 5)));
- Table.States (856).Action_List.Set_Capacity (1);
- Add_Action (Table.States (856), 96, 1016);
- Table.States (856).Kernel := To_Vector ((0 => (152, 61, 1,
False)));
- Table.States (856).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1016)));
+ Add_Action (Table.States (855), 21, Reduce, (195, 1), 5,
extended_return_object_declaration_1'Access,
+ null);
+ Add_Action (Table.States (855), 83, 1020);
+ Add_Action (Table.States (855), 97, Reduce, (195, 1), 5,
extended_return_object_declaration_1'Access,
+ null);
+ Table.States (855).Kernel := To_Vector (((195, 293, 1, False),
(195, 293, 0, False)));
+ Table.States (855).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 195, 5)));
+ Table.States (856).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (856), (21, 83, 97), (293, 0), 1, null,
null);
+ Table.States (856).Kernel := To_Vector ((0 => (293, 315, 0,
False)));
+ Table.States (856).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 293, 1)));
Table.States (857).Action_List.Set_Capacity (1);
- Add_Action (Table.States (857), 96, 1017);
- Table.States (857).Kernel := To_Vector ((0 => (323, 61, 1,
False)));
- Table.States (857).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1017)));
- Table.States (858).Action_List.Set_Capacity (1);
- Add_Action (Table.States (858), 96, 1018);
- Table.States (858).Kernel := To_Vector ((0 => (294, 61, 1,
False)));
- Table.States (858).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1018)));
+ Add_Action (Table.States (857), 97, 1021);
+ Table.States (857).Kernel := To_Vector ((0 => (197, 58, 1,
False)));
+ Table.States (857).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1021)));
+ Table.States (858).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (858), 79, 31);
+ Add_Action (Table.States (858), 105, 120);
+ Add_Action (Table.States (858), 106, 34);
+ Add_Action (Table.States (858), 107, 35);
+ Table.States (858).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (858), 129, 42);
+ Add_Goto (Table.States (858), 240, 1022);
+ Add_Goto (Table.States (858), 273, 93);
+ Add_Goto (Table.States (858), 294, 98);
+ Table.States (858).Kernel := To_Vector (((248, 14, 5, False),
(248, 14, 4, False)));
+ Table.States (858).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
Table.States (859).Action_List.Set_Capacity (1);
- Add_Action (Table.States (859), 61, 1019);
- Table.States (859).Kernel := To_Vector ((0 => (126, 24, 2,
False)));
- Table.States (859).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 61, 1019)));
- Table.States (860).Action_List.Set_Capacity (40);
- Add_Action (Table.States (860), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (313, 0), 6,
+ Add_Action (Table.States (859), 105, 1023);
+ Table.States (859).Kernel := To_Vector ((0 => (265, 14, 4,
False)));
+ Table.States (859).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 1023)));
+ Table.States (860).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (860), 105, 1024);
+ Table.States (860).Kernel := To_Vector ((0 => (317, 14, 5,
False)));
+ Table.States (860).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 1024)));
+ Table.States (861).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (861), 35, Reduce, (123, 1), 0, null,
null);
+ Add_Action (Table.States (861), 74, 338);
+ Table.States (861).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (861), 123, 1025);
+ Table.States (861).Kernel := To_Vector ((0 => (308, 313, 4,
False)));
+ Table.States (861).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (862).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (862), (22, 24, 43), (296, 1), 5,
select_alternative_1'Access, null);
+ Table.States (862).Kernel := To_Vector ((0 => (296, 97, 0,
False)));
+ Table.States (862).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 296, 5)));
+ Table.States (863).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (863), (22, 24, 43), (296, 0), 5,
select_alternative_0'Access, null);
+ Table.States (863).Kernel := To_Vector ((0 => (296, 301, 0,
False)));
+ Table.States (863).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 296, 5)));
+ Table.States (864).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (864), 97, 1026);
+ Table.States (864).Kernel := To_Vector ((0 => (153, 61, 1,
False)));
+ Table.States (864).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1026)));
+ Table.States (865).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (865), 97, 1027);
+ Table.States (865).Kernel := To_Vector ((0 => (324, 61, 1,
False)));
+ Table.States (865).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1027)));
+ Table.States (866).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (866), 97, 1028);
+ Table.States (866).Kernel := To_Vector ((0 => (295, 61, 1,
False)));
+ Table.States (866).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1028)));
+ Table.States (867).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (867), 61, 1029);
+ Table.States (867).Kernel := To_Vector ((0 => (127, 24, 2,
False)));
+ Table.States (867).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 61, 1029)));
+ Table.States (868).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (868), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (314, 0), 6,
subtype_declaration_0'Access, null);
- Table.States (860).Kernel := To_Vector ((0 => (313, 96, 0,
False)));
- Table.States (860).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 313, 6)));
- Table.States (861).Action_List.Set_Capacity (1);
- Add_Action (Table.States (861), 96, 1020);
- Table.States (861).Kernel := To_Vector ((0 => (317, 122, 1,
False)));
- Table.States (861).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1020)));
- Table.States (862).Action_List.Set_Capacity (1);
- Add_Action (Table.States (862), 13, 1021);
- Table.States (862).Kernel := To_Vector ((0 => (316, 159, 3,
False)));
- Table.States (862).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 13, 1021)));
- Table.States (863).Action_List.Set_Capacity (18);
- Add_Action (Table.States (863), 24, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (863), 25, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (863), 28, 183);
- Add_Action (Table.States (863), 29, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (863), 30, 8);
- Add_Action (Table.States (863), 39, 1022);
- Add_Action (Table.States (863), 40, 12);
- Add_Action (Table.States (863), 46, 14);
- Add_Action (Table.States (863), 47, 15);
- Add_Action (Table.States (863), 48, 16);
- Add_Action (Table.States (863), 49, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (863), 50, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (863), 51, 19);
- Add_Action (Table.States (863), 63, 25);
- Add_Action (Table.States (863), 66, 26);
- Add_Action (Table.States (863), 69, 27);
- Add_Action (Table.States (863), 71, 28);
- Add_Action (Table.States (863), 104, 185);
- Table.States (863).Goto_List.Set_Capacity (54);
- Add_Goto (Table.States (863), 112, 35);
- Add_Goto (Table.States (863), 121, 37);
- Add_Goto (Table.States (863), 127, 40);
- Add_Goto (Table.States (863), 134, 45);
- Add_Goto (Table.States (863), 135, 46);
- Add_Goto (Table.States (863), 157, 391);
- Add_Goto (Table.States (863), 158, 392);
- Add_Goto (Table.States (863), 159, 694);
- Add_Goto (Table.States (863), 179, 54);
- Add_Goto (Table.States (863), 182, 55);
- Add_Goto (Table.States (863), 186, 56);
- Add_Goto (Table.States (863), 193, 58);
- Add_Goto (Table.States (863), 206, 60);
- Add_Goto (Table.States (863), 207, 61);
- Add_Goto (Table.States (863), 209, 62);
- Add_Goto (Table.States (863), 210, 63);
- Add_Goto (Table.States (863), 213, 64);
- Add_Goto (Table.States (863), 214, 65);
- Add_Goto (Table.States (863), 215, 66);
- Add_Goto (Table.States (863), 216, 67);
- Add_Goto (Table.States (863), 219, 69);
- Add_Goto (Table.States (863), 223, 71);
- Add_Goto (Table.States (863), 243, 74);
- Add_Goto (Table.States (863), 244, 75);
- Add_Goto (Table.States (863), 245, 76);
- Add_Goto (Table.States (863), 246, 77);
- Add_Goto (Table.States (863), 247, 78);
- Add_Goto (Table.States (863), 248, 79);
- Add_Goto (Table.States (863), 249, 80);
- Add_Goto (Table.States (863), 250, 81);
- Add_Goto (Table.States (863), 251, 82);
- Add_Goto (Table.States (863), 257, 394);
- Add_Goto (Table.States (863), 259, 84);
- Add_Goto (Table.States (863), 260, 85);
- Add_Goto (Table.States (863), 262, 87);
- Add_Goto (Table.States (863), 263, 88);
- Add_Goto (Table.States (863), 264, 89);
- Add_Goto (Table.States (863), 265, 90);
- Add_Goto (Table.States (863), 271, 91);
- Add_Goto (Table.States (863), 281, 94);
- Add_Goto (Table.States (863), 289, 95);
- Add_Goto (Table.States (863), 304, 102);
- Add_Goto (Table.States (863), 305, 103);
- Add_Goto (Table.States (863), 307, 105);
- Add_Goto (Table.States (863), 308, 106);
- Add_Goto (Table.States (863), 309, 107);
- Add_Goto (Table.States (863), 311, 108);
- Add_Goto (Table.States (863), 313, 109);
- Add_Goto (Table.States (863), 316, 111);
- Add_Goto (Table.States (863), 317, 112);
- Add_Goto (Table.States (863), 318, 1023);
- Add_Goto (Table.States (863), 319, 113);
- Add_Goto (Table.States (863), 325, 115);
- Add_Goto (Table.States (863), 331, 116);
- Table.States (863).Kernel := To_Vector (((319, 35, 5, False),
(319, 35, 2, False)));
- Table.States (863).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 318, 0)));
- Table.States (864).Action_List.Set_Capacity (40);
- Add_Action (Table.States (864), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (319, 2), 6,
- task_type_declaration_2'Access, null);
- Table.States (864).Kernel := To_Vector ((0 => (319, 96, 0,
False)));
- Table.States (864).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 319, 6)));
- Table.States (865).Action_List.Set_Capacity (2);
- Add_Action (Table.States (865), 10, 1006);
- Add_Action (Table.States (865), 74, 1024);
- Table.States (865).Kernel := To_Vector (((227, 227, 2, True),
(305, 227, 3, False)));
- Table.States (865).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 74, 1024)));
- Table.States (866).Action_List.Set_Capacity (16);
- Add_Action (Table.States (866), 24, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (866), 25, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (866), 28, 183);
- Add_Action (Table.States (866), 29, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (866), 30, 8);
- Add_Action (Table.States (866), 40, 12);
- Add_Action (Table.States (866), 46, 14);
- Add_Action (Table.States (866), 47, 15);
- Add_Action (Table.States (866), 48, 16);
- Add_Action (Table.States (866), 50, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (866), 51, 19);
- Add_Action (Table.States (866), 63, 25);
- Add_Action (Table.States (866), 66, 26);
- Add_Action (Table.States (866), 69, 27);
- Add_Action (Table.States (866), 71, 28);
- Add_Action (Table.States (866), 104, 185);
- Table.States (866).Goto_List.Set_Capacity (53);
- Add_Goto (Table.States (866), 112, 35);
- Add_Goto (Table.States (866), 121, 37);
- Add_Goto (Table.States (866), 127, 40);
- Add_Goto (Table.States (866), 134, 45);
- Add_Goto (Table.States (866), 135, 46);
- Add_Goto (Table.States (866), 157, 391);
- Add_Goto (Table.States (866), 158, 392);
- Add_Goto (Table.States (866), 159, 1025);
- Add_Goto (Table.States (866), 179, 54);
- Add_Goto (Table.States (866), 182, 55);
- Add_Goto (Table.States (866), 186, 56);
- Add_Goto (Table.States (866), 193, 58);
- Add_Goto (Table.States (866), 206, 60);
- Add_Goto (Table.States (866), 207, 61);
- Add_Goto (Table.States (866), 209, 62);
- Add_Goto (Table.States (866), 210, 63);
- Add_Goto (Table.States (866), 213, 64);
- Add_Goto (Table.States (866), 214, 65);
- Add_Goto (Table.States (866), 215, 66);
- Add_Goto (Table.States (866), 216, 67);
- Add_Goto (Table.States (866), 219, 69);
- Add_Goto (Table.States (866), 223, 71);
- Add_Goto (Table.States (866), 243, 74);
- Add_Goto (Table.States (866), 244, 75);
- Add_Goto (Table.States (866), 245, 76);
- Add_Goto (Table.States (866), 246, 77);
- Add_Goto (Table.States (866), 247, 78);
- Add_Goto (Table.States (866), 248, 79);
- Add_Goto (Table.States (866), 249, 80);
- Add_Goto (Table.States (866), 250, 81);
- Add_Goto (Table.States (866), 251, 82);
- Add_Goto (Table.States (866), 257, 394);
- Add_Goto (Table.States (866), 259, 84);
- Add_Goto (Table.States (866), 260, 85);
- Add_Goto (Table.States (866), 262, 87);
- Add_Goto (Table.States (866), 263, 88);
- Add_Goto (Table.States (866), 264, 89);
- Add_Goto (Table.States (866), 265, 90);
- Add_Goto (Table.States (866), 271, 91);
- Add_Goto (Table.States (866), 281, 94);
- Add_Goto (Table.States (866), 289, 95);
- Add_Goto (Table.States (866), 304, 102);
- Add_Goto (Table.States (866), 305, 103);
- Add_Goto (Table.States (866), 307, 105);
- Add_Goto (Table.States (866), 308, 106);
- Add_Goto (Table.States (866), 309, 107);
- Add_Goto (Table.States (866), 311, 108);
- Add_Goto (Table.States (866), 313, 109);
- Add_Goto (Table.States (866), 316, 111);
- Add_Goto (Table.States (866), 317, 112);
- Add_Goto (Table.States (866), 319, 113);
- Add_Goto (Table.States (866), 325, 115);
- Add_Goto (Table.States (866), 331, 116);
- Table.States (866).Kernel := To_Vector ((0 => (318, 49, 0,
False)));
- Table.States (866).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 159, 0)));
- Table.States (867).Action_List.Set_Capacity (2);
- Add_Action (Table.States (867), 96, Reduce, (220, 1), 0, null,
null);
- Add_Action (Table.States (867), 104, 149);
- Table.States (867).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (867), 220, 1026);
- Table.States (867).Kernel := To_Vector ((0 => (305, 24, 1,
False)));
- Table.States (867).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 220, 0)));
- Table.States (868).Action_List.Set_Capacity (2);
- Add_Action (Table.States (868), (77, 96), (171, 0), 3, null, null);
- Table.States (868).Kernel := To_Vector ((0 => (171, 170, 0,
True)));
- Table.States (868).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 171, 3)));
- Table.States (868).Minimal_Complete_Actions_Recursive := True;
+ Table.States (868).Kernel := To_Vector ((0 => (314, 97, 0,
False)));
+ Table.States (868).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 314, 6)));
Table.States (869).Action_List.Set_Capacity (1);
- Add_Action (Table.States (869), 41, 1027);
- Table.States (869).Kernel := To_Vector (((241, 40, 1, False),
(242, 40, 2, False), (242, 40, 4, False)));
- Table.States (869).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 41, 1027)));
- Table.States (870).Action_List.Set_Capacity (7);
- Add_Action (Table.States (870), 76, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (870), 77, Reduce, (242, 0), 1,
null_exclusion_opt_name_type_0'Access, null);
- Add_Action (Table.States (870), 82, Reduce, (242, 0), 1,
null_exclusion_opt_name_type_0'Access, null);
- Add_Action (Table.States (870), 84, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (870), 96, Reduce, (242, 0), 1,
null_exclusion_opt_name_type_0'Access, null);
- Add_Action (Table.States (870), 101, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (870), 102, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Table.States (870).Kernel := To_Vector (((239, 104, 0, False),
(242, 104, 0, False)));
- Table.States (870).Minimal_Complete_Actions := To_Vector
(((Reduce, 239, 1), (Reduce, 242, 1)));
- Table.States (871).Action_List.Set_Capacity (3);
- Add_Action (Table.States (871), 77, Reduce, (170, 3), 3, null,
null);
- Add_Action (Table.States (871), 82, 1028);
- Add_Action (Table.States (871), 96, Reduce, (170, 3), 3, null,
null);
- Table.States (871).Kernel := To_Vector (((170, 114, 1, False),
(170, 114, 0, False)));
- Table.States (871).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 170, 3)));
- Table.States (872).Action_List.Set_Capacity (4);
- Add_Action (Table.States (872), 76, 235);
- Add_Action (Table.States (872), 84, 237);
- Add_Action (Table.States (872), 101, 239);
- Add_Action (Table.States (872), 102, 240);
- Table.States (872).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (872), 115, 241);
- Add_Goto (Table.States (872), 322, 242);
- Table.States (872).Kernel := To_Vector (((128, 239, 2, True),
(239, 239, 5, True), (239, 239, 2, True),
- (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True)));
- Table.States (872).Minimal_Complete_Actions := To_Vector (((Shift,
101, 239), (Shift, 76, 235), (Shift, 84,
- 237)));
- Table.States (872).Minimal_Complete_Actions_Recursive := True;
- Table.States (873).Action_List.Set_Capacity (3);
- Add_Action (Table.States (873), 77, Reduce, (170, 2), 3, null,
null);
- Add_Action (Table.States (873), 82, 1029);
- Add_Action (Table.States (873), 96, Reduce, (170, 2), 3, null,
null);
- Table.States (873).Kernel := To_Vector (((170, 242, 1, False),
(170, 242, 0, False)));
- Table.States (873).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 170, 3)));
- Table.States (874).Action_List.Set_Capacity (7);
- Add_Action (Table.States (874), 76, Reduce, (239, 2), 1, null,
name_2_check'Access);
- Add_Action (Table.States (874), 77, Reduce, (242, 1), 1,
null_exclusion_opt_name_type_1'Access, null);
- Add_Action (Table.States (874), 82, Reduce, (242, 1), 1,
null_exclusion_opt_name_type_1'Access, null);
- Add_Action (Table.States (874), 84, Reduce, (239, 2), 1, null,
name_2_check'Access);
- Add_Action (Table.States (874), 96, Reduce, (242, 1), 1,
null_exclusion_opt_name_type_1'Access, null);
- Add_Action (Table.States (874), 101, Reduce, (239, 2), 1, null,
name_2_check'Access);
- Add_Action (Table.States (874), 102, Reduce, (239, 2), 1, null,
name_2_check'Access);
- Table.States (874).Kernel := To_Vector (((239, 293, 0, True),
(242, 293, 0, False)));
- Table.States (874).Minimal_Complete_Actions := To_Vector
(((Reduce, 239, 1), (Reduce, 242, 1)));
- Table.States (874).Minimal_Complete_Actions_Recursive := True;
- Table.States (875).Action_List.Set_Capacity (1);
- Add_Action (Table.States (875), 39, Reduce, (109, 0), 2, null,
null);
- Add_Conflict (Table.States (875), 39, (110, 0), 2, null, null);
- Table.States (875).Kernel := To_Vector (((109, 36, 0, False),
(110, 36, 0, False)));
- Table.States (875).Minimal_Complete_Actions := To_Vector
(((Reduce, 109, 2), (Reduce, 110, 2)));
- Table.States (876).Action_List.Set_Capacity (1);
- Add_Action (Table.States (876), (1 => 39), (109, 1), 2, null,
null);
- Table.States (876).Kernel := To_Vector ((0 => (109, 64, 0,
False)));
- Table.States (876).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 109, 2)));
- Table.States (877).Action_List.Set_Capacity (4);
- Add_Action (Table.States (877), 36, 1030);
- Add_Action (Table.States (877), 41, Reduce, (111, 1), 2, null,
null);
- Add_Action (Table.States (877), 49, Reduce, (111, 1), 2, null,
null);
- Add_Action (Table.States (877), 54, Reduce, (111, 1), 2, null,
null);
- Table.States (877).Kernel := To_Vector (((111, 65, 1, False),
(111, 65, 0, False)));
- Table.States (877).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 111, 2)));
- Table.States (878).Action_List.Set_Capacity (11);
- Add_Action (Table.States (878), 3, 121);
- Add_Action (Table.States (878), 39, 122);
- Add_Action (Table.States (878), 40, 474);
- Add_Action (Table.States (878), 41, 124);
- Add_Action (Table.States (878), 76, 126);
- Add_Action (Table.States (878), 94, 127);
- Add_Action (Table.States (878), 95, 128);
- Add_Action (Table.States (878), 103, 129);
- Add_Action (Table.States (878), 104, 119);
- Add_Action (Table.States (878), 105, 33);
- Add_Action (Table.States (878), 106, 34);
- Table.States (878).Goto_List.Set_Capacity (17);
- Add_Goto (Table.States (878), 117, 130);
- Add_Goto (Table.States (878), 128, 41);
- Add_Goto (Table.States (878), 167, 776);
- Add_Goto (Table.States (878), 168, 1031);
- Add_Goto (Table.States (878), 197, 133);
- Add_Goto (Table.States (878), 225, 1032);
- Add_Goto (Table.States (878), 226, 1033);
- Add_Goto (Table.States (878), 239, 1034);
- Add_Goto (Table.States (878), 258, 135);
- Add_Goto (Table.States (878), 272, 92);
- Add_Goto (Table.States (878), 277, 478);
- Add_Goto (Table.States (878), 293, 97);
- Add_Goto (Table.States (878), 301, 479);
- Add_Goto (Table.States (878), 314, 480);
- Add_Goto (Table.States (878), 320, 144);
- Add_Goto (Table.States (878), 321, 145);
- Add_Goto (Table.States (878), 330, 146);
- Table.States (878).Kernel := To_Vector (((120, 76, 6, False),
(120, 76, 6, False)));
- Table.States (878).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (879).Action_List.Set_Capacity (4);
- Add_Action (Table.States (879), 20, 1035);
- Add_Action (Table.States (879), 53, 1036);
- Add_Action (Table.States (879), 74, Reduce, (279, 1), 0, null,
null);
- Add_Action (Table.States (879), 96, Reduce, (279, 1), 0, null,
null);
- Table.States (879).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (879), 279, 1037);
- Table.States (879).Kernel := To_Vector (((326, 192, 1, False),
(326, 192, 0, False)));
- Table.States (879).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 279, 0)));
- Table.States (880).Action_List.Set_Capacity (3);
- Add_Action (Table.States (880), 53, 1036);
- Add_Action (Table.States (880), 74, Reduce, (279, 1), 0, null,
null);
- Add_Action (Table.States (880), 96, Reduce, (279, 1), 0, null,
null);
- Table.States (880).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (880), 279, 1038);
- Table.States (880).Kernel := To_Vector ((0 => (326, 192, 0,
False)));
- Table.States (880).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 279, 0)));
+ Add_Action (Table.States (869), 97, 1030);
+ Table.States (869).Kernel := To_Vector ((0 => (318, 123, 1,
False)));
+ Table.States (869).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1030)));
+ Table.States (870).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (870), 13, 1031);
+ Table.States (870).Kernel := To_Vector ((0 => (317, 160, 3,
False)));
+ Table.States (870).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 13, 1031)));
+ Table.States (871).Action_List.Set_Capacity (18);
+ Add_Action (Table.States (871), 24, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (871), 25, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (871), 28, 184);
+ Add_Action (Table.States (871), 29, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (871), 30, 8);
+ Add_Action (Table.States (871), 39, 1032);
+ Add_Action (Table.States (871), 40, 12);
+ Add_Action (Table.States (871), 46, 14);
+ Add_Action (Table.States (871), 47, 15);
+ Add_Action (Table.States (871), 48, 16);
+ Add_Action (Table.States (871), 49, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (871), 50, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (871), 51, 19);
+ Add_Action (Table.States (871), 63, 25);
+ Add_Action (Table.States (871), 66, 26);
+ Add_Action (Table.States (871), 69, 27);
+ Add_Action (Table.States (871), 71, 28);
+ Add_Action (Table.States (871), 105, 186);
+ Table.States (871).Goto_List.Set_Capacity (54);
+ Add_Goto (Table.States (871), 113, 36);
+ Add_Goto (Table.States (871), 122, 38);
+ Add_Goto (Table.States (871), 128, 41);
+ Add_Goto (Table.States (871), 135, 46);
+ Add_Goto (Table.States (871), 136, 47);
+ Add_Goto (Table.States (871), 158, 392);
+ Add_Goto (Table.States (871), 159, 393);
+ Add_Goto (Table.States (871), 160, 700);
+ Add_Goto (Table.States (871), 180, 55);
+ Add_Goto (Table.States (871), 183, 56);
+ Add_Goto (Table.States (871), 187, 57);
+ Add_Goto (Table.States (871), 194, 59);
+ Add_Goto (Table.States (871), 207, 61);
+ Add_Goto (Table.States (871), 208, 62);
+ Add_Goto (Table.States (871), 210, 63);
+ Add_Goto (Table.States (871), 211, 64);
+ Add_Goto (Table.States (871), 214, 65);
+ Add_Goto (Table.States (871), 215, 66);
+ Add_Goto (Table.States (871), 216, 67);
+ Add_Goto (Table.States (871), 217, 68);
+ Add_Goto (Table.States (871), 220, 70);
+ Add_Goto (Table.States (871), 224, 72);
+ Add_Goto (Table.States (871), 244, 75);
+ Add_Goto (Table.States (871), 245, 76);
+ Add_Goto (Table.States (871), 246, 77);
+ Add_Goto (Table.States (871), 247, 78);
+ Add_Goto (Table.States (871), 248, 79);
+ Add_Goto (Table.States (871), 249, 80);
+ Add_Goto (Table.States (871), 250, 81);
+ Add_Goto (Table.States (871), 251, 82);
+ Add_Goto (Table.States (871), 252, 83);
+ Add_Goto (Table.States (871), 258, 395);
+ Add_Goto (Table.States (871), 260, 85);
+ Add_Goto (Table.States (871), 261, 86);
+ Add_Goto (Table.States (871), 263, 88);
+ Add_Goto (Table.States (871), 264, 89);
+ Add_Goto (Table.States (871), 265, 90);
+ Add_Goto (Table.States (871), 266, 91);
+ Add_Goto (Table.States (871), 272, 92);
+ Add_Goto (Table.States (871), 282, 95);
+ Add_Goto (Table.States (871), 290, 96);
+ Add_Goto (Table.States (871), 305, 103);
+ Add_Goto (Table.States (871), 306, 104);
+ Add_Goto (Table.States (871), 308, 106);
+ Add_Goto (Table.States (871), 309, 107);
+ Add_Goto (Table.States (871), 310, 108);
+ Add_Goto (Table.States (871), 312, 109);
+ Add_Goto (Table.States (871), 314, 110);
+ Add_Goto (Table.States (871), 317, 112);
+ Add_Goto (Table.States (871), 318, 113);
+ Add_Goto (Table.States (871), 319, 1033);
+ Add_Goto (Table.States (871), 320, 114);
+ Add_Goto (Table.States (871), 326, 116);
+ Add_Goto (Table.States (871), 332, 117);
+ Table.States (871).Kernel := To_Vector (((320, 35, 5, False),
(320, 35, 2, False)));
+ Table.States (871).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 319, 0)));
+ Table.States (872).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (872), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (320, 2), 6,
+ task_type_declaration_2'Access, null);
+ Table.States (872).Kernel := To_Vector ((0 => (320, 97, 0,
False)));
+ Table.States (872).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 320, 6)));
+ Table.States (873).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (873), 10, 1016);
+ Add_Action (Table.States (873), 74, 1034);
+ Table.States (873).Kernel := To_Vector (((228, 228, 2, True),
(306, 228, 3, False)));
+ Table.States (873).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 74, 1034)));
+ Table.States (874).Action_List.Set_Capacity (16);
+ Add_Action (Table.States (874), 24, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (874), 25, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (874), 28, 184);
+ Add_Action (Table.States (874), 29, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (874), 30, 8);
+ Add_Action (Table.States (874), 40, 12);
+ Add_Action (Table.States (874), 46, 14);
+ Add_Action (Table.States (874), 47, 15);
+ Add_Action (Table.States (874), 48, 16);
+ Add_Action (Table.States (874), 50, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (874), 51, 19);
+ Add_Action (Table.States (874), 63, 25);
+ Add_Action (Table.States (874), 66, 26);
+ Add_Action (Table.States (874), 69, 27);
+ Add_Action (Table.States (874), 71, 28);
+ Add_Action (Table.States (874), 105, 186);
+ Table.States (874).Goto_List.Set_Capacity (53);
+ Add_Goto (Table.States (874), 113, 36);
+ Add_Goto (Table.States (874), 122, 38);
+ Add_Goto (Table.States (874), 128, 41);
+ Add_Goto (Table.States (874), 135, 46);
+ Add_Goto (Table.States (874), 136, 47);
+ Add_Goto (Table.States (874), 158, 392);
+ Add_Goto (Table.States (874), 159, 393);
+ Add_Goto (Table.States (874), 160, 1035);
+ Add_Goto (Table.States (874), 180, 55);
+ Add_Goto (Table.States (874), 183, 56);
+ Add_Goto (Table.States (874), 187, 57);
+ Add_Goto (Table.States (874), 194, 59);
+ Add_Goto (Table.States (874), 207, 61);
+ Add_Goto (Table.States (874), 208, 62);
+ Add_Goto (Table.States (874), 210, 63);
+ Add_Goto (Table.States (874), 211, 64);
+ Add_Goto (Table.States (874), 214, 65);
+ Add_Goto (Table.States (874), 215, 66);
+ Add_Goto (Table.States (874), 216, 67);
+ Add_Goto (Table.States (874), 217, 68);
+ Add_Goto (Table.States (874), 220, 70);
+ Add_Goto (Table.States (874), 224, 72);
+ Add_Goto (Table.States (874), 244, 75);
+ Add_Goto (Table.States (874), 245, 76);
+ Add_Goto (Table.States (874), 246, 77);
+ Add_Goto (Table.States (874), 247, 78);
+ Add_Goto (Table.States (874), 248, 79);
+ Add_Goto (Table.States (874), 249, 80);
+ Add_Goto (Table.States (874), 250, 81);
+ Add_Goto (Table.States (874), 251, 82);
+ Add_Goto (Table.States (874), 252, 83);
+ Add_Goto (Table.States (874), 258, 395);
+ Add_Goto (Table.States (874), 260, 85);
+ Add_Goto (Table.States (874), 261, 86);
+ Add_Goto (Table.States (874), 263, 88);
+ Add_Goto (Table.States (874), 264, 89);
+ Add_Goto (Table.States (874), 265, 90);
+ Add_Goto (Table.States (874), 266, 91);
+ Add_Goto (Table.States (874), 272, 92);
+ Add_Goto (Table.States (874), 282, 95);
+ Add_Goto (Table.States (874), 290, 96);
+ Add_Goto (Table.States (874), 305, 103);
+ Add_Goto (Table.States (874), 306, 104);
+ Add_Goto (Table.States (874), 308, 106);
+ Add_Goto (Table.States (874), 309, 107);
+ Add_Goto (Table.States (874), 310, 108);
+ Add_Goto (Table.States (874), 312, 109);
+ Add_Goto (Table.States (874), 314, 110);
+ Add_Goto (Table.States (874), 317, 112);
+ Add_Goto (Table.States (874), 318, 113);
+ Add_Goto (Table.States (874), 320, 114);
+ Add_Goto (Table.States (874), 326, 116);
+ Add_Goto (Table.States (874), 332, 117);
+ Table.States (874).Kernel := To_Vector ((0 => (319, 49, 0,
False)));
+ Table.States (874).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 160, 0)));
+ Table.States (875).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (875), 97, Reduce, (221, 1), 0, null,
null);
+ Add_Action (Table.States (875), 105, 150);
+ Table.States (875).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (875), 221, 1036);
+ Table.States (875).Kernel := To_Vector ((0 => (306, 24, 1,
False)));
+ Table.States (875).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 221, 0)));
+ Table.States (876).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (876), (77, 97), (172, 0), 3, null, null);
+ Table.States (876).Kernel := To_Vector ((0 => (172, 171, 0,
True)));
+ Table.States (876).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 172, 3)));
+ Table.States (876).Minimal_Complete_Actions_Recursive := True;
+ Table.States (877).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (877), 41, 1037);
+ Table.States (877).Kernel := To_Vector (((242, 40, 1, False),
(243, 40, 2, False), (243, 40, 4, False)));
+ Table.States (877).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 41, 1037)));
+ Table.States (878).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (878), 76, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (878), 77, Reduce, (243, 0), 1,
null_exclusion_opt_name_type_0'Access, null);
+ Add_Action (Table.States (878), 83, Reduce, (243, 0), 1,
null_exclusion_opt_name_type_0'Access, null);
+ Add_Action (Table.States (878), 85, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (878), 97, Reduce, (243, 0), 1,
null_exclusion_opt_name_type_0'Access, null);
+ Add_Action (Table.States (878), 102, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (878), 103, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Table.States (878).Kernel := To_Vector (((240, 105, 0, False),
(243, 105, 0, False)));
+ Table.States (878).Minimal_Complete_Actions := To_Vector
(((Reduce, 240, 1), (Reduce, 243, 1)));
+ Table.States (879).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (879), 77, Reduce, (171, 3), 3, null,
null);
+ Add_Action (Table.States (879), 83, 1038);
+ Add_Action (Table.States (879), 97, Reduce, (171, 3), 3, null,
null);
+ Table.States (879).Kernel := To_Vector (((171, 115, 1, False),
(171, 115, 0, False)));
+ Table.States (879).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 171, 3)));
+ Table.States (880).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (880), 76, 236);
+ Add_Action (Table.States (880), 85, 238);
+ Add_Action (Table.States (880), 102, 240);
+ Add_Action (Table.States (880), 103, 241);
+ Table.States (880).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (880), 116, 242);
+ Add_Goto (Table.States (880), 323, 243);
+ Table.States (880).Kernel := To_Vector (((129, 240, 2, True),
(240, 240, 5, True), (240, 240, 2, True),
+ (273, 240, 3, True), (294, 240, 2, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True)));
+ Table.States (880).Minimal_Complete_Actions := To_Vector (((Shift,
102, 240), (Shift, 76, 236), (Shift, 85,
+ 238)));
+ Table.States (880).Minimal_Complete_Actions_Recursive := True;
Table.States (881).Action_List.Set_Capacity (3);
- Add_Action (Table.States (881), 10, 1039);
- Add_Action (Table.States (881), 74, Reduce, (228, 4), 2, null,
null);
- Add_Action (Table.States (881), 96, Reduce, (228, 4), 2, null,
null);
- Table.States (881).Kernel := To_Vector (((228, 34, 2, False),
(228, 34, 0, False)));
- Table.States (881).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 228, 2)));
- Table.States (882).Action_List.Set_Capacity (2);
- Add_Action (Table.States (882), (74, 96), (326, 2), 2, null, null);
- Table.States (882).Kernel := To_Vector ((0 => (326, 192, 0,
False)));
- Table.States (882).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 326, 2)));
- Table.States (883).Action_List.Set_Capacity (2);
- Add_Action (Table.States (883), (74, 96), (280, 1), 2, null, null);
- Table.States (883).Kernel := To_Vector ((0 => (280, 54, 0,
False)));
- Table.States (883).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 280, 2)));
- Table.States (884).Action_List.Set_Capacity (3);
- Add_Action (Table.States (884), 10, 1040);
- Add_Action (Table.States (884), 74, Reduce, (228, 6), 2, null,
null);
- Add_Action (Table.States (884), 96, Reduce, (228, 6), 2, null,
null);
- Table.States (884).Kernel := To_Vector (((228, 34, 2, False),
(228, 34, 0, False)));
- Table.States (884).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 228, 2)));
- Table.States (885).Action_List.Set_Capacity (1);
- Add_Action (Table.States (885), 85, 1041);
- Table.States (885).Kernel := To_Vector ((0 => (326, 301, 2,
False)));
- Table.States (885).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 85, 1041)));
- Table.States (886).Action_List.Set_Capacity (3);
- Add_Action (Table.States (886), 35, Reduce, (164, 1), 0, null,
null);
- Add_Action (Table.States (886), 104, 1042);
- Add_Action (Table.States (886), 105, 1043);
- Table.States (886).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (886), 163, 1044);
- Add_Goto (Table.States (886), 164, 1045);
- Table.States (886).Kernel := To_Vector ((0 => (327, 15, 6,
False)));
- Table.States (886).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 164, 0)));
- end Subr_15;
- procedure Subr_16
- is begin
- Table.States (887).Action_List.Set_Capacity (1);
- Add_Action (Table.States (887), 96, 1046);
- Table.States (887).Kernel := To_Vector ((0 => (149, 41, 1,
False)));
- Table.States (887).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1046)));
- Table.States (888).Action_List.Set_Capacity (5);
- Add_Action (Table.States (888), (15, 24, 28, 72, 104), (148, 1),
1, null, null);
- Table.States (888).Kernel := To_Vector ((0 => (148, 121, 0,
False)));
- Table.States (888).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 148, 1)));
- Table.States (889).Action_List.Set_Capacity (5);
- Add_Action (Table.States (889), (15, 24, 28, 72, 104), (148, 0),
1, null, null);
- Table.States (889).Kernel := To_Vector ((0 => (148, 146, 0,
False)));
- Table.States (889).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 148, 1)));
- Table.States (890).Action_List.Set_Capacity (5);
- Add_Action (Table.States (890), (15, 24, 28, 72, 104), (149, 2),
1, null, null);
- Table.States (890).Kernel := To_Vector ((0 => (149, 148, 0,
False)));
- Table.States (890).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 149, 1)));
- Table.States (891).Action_List.Set_Capacity (5);
- Add_Action (Table.States (891), 15, 886);
- Add_Action (Table.States (891), 24, Reduce, (150, 0), 1, null,
null);
- Add_Action (Table.States (891), 28, 183);
- Add_Action (Table.States (891), 72, Reduce, (150, 0), 1, null,
null);
- Add_Action (Table.States (891), 104, 164);
- Table.States (891).Goto_List.Set_Capacity (8);
- Add_Goto (Table.States (891), 121, 888);
- Add_Goto (Table.States (891), 127, 40);
- Add_Goto (Table.States (891), 146, 889);
- Add_Goto (Table.States (891), 148, 1047);
- Add_Goto (Table.States (891), 182, 55);
- Add_Goto (Table.States (891), 219, 893);
- Add_Goto (Table.States (891), 281, 94);
- Add_Goto (Table.States (891), 327, 1048);
- Table.States (891).Kernel := To_Vector (((149, 149, 4, True),
(149, 149, 7, True), (150, 149, 0, False)));
- Table.States (891).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 150, 1)));
- Table.States (892).Action_List.Set_Capacity (1);
- Add_Action (Table.States (892), 24, 1049);
- Table.States (892).Kernel := To_Vector ((0 => (280, 150, 2,
False)));
- Table.States (892).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1049)));
- Table.States (893).Action_List.Set_Capacity (2);
- Add_Action (Table.States (893), 81, 1050);
- Add_Action (Table.States (893), 83, 234);
- Table.States (893).Kernel := To_Vector (((146, 219, 4, False),
(146, 219, 3, False), (219, 219, 2, True)));
- Table.States (893).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 81, 1050)));
- Table.States (894).Action_List.Set_Capacity (5);
- Add_Action (Table.States (894), (15, 24, 28, 72, 104), (149, 3),
1, null, null);
- Table.States (894).Kernel := To_Vector ((0 => (149, 327, 0,
False)));
- Table.States (894).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 149, 1)));
- Table.States (895).Action_List.Set_Capacity (3);
- Add_Action (Table.States (895), 10, 1051);
- Add_Action (Table.States (895), 74, Reduce, (228, 7), 2, null,
null);
- Add_Action (Table.States (895), 96, Reduce, (228, 7), 2, null,
null);
- Table.States (895).Kernel := To_Vector (((228, 34, 2, False),
(228, 34, 0, False)));
- Table.States (895).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 228, 2)));
- Table.States (896).Action_List.Set_Capacity (3);
- Add_Action (Table.States (896), (41, 49, 54), (111, 2), 2, null,
null);
- Table.States (896).Kernel := To_Vector ((0 => (111, 36, 0,
False)));
- Table.States (896).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 111, 2)));
- Table.States (897).Action_List.Set_Capacity (40);
- Add_Action (Table.States (897), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (223, 0), 6,
- incomplete_type_declaration_0'Access, null);
- Table.States (897).Kernel := To_Vector ((0 => (223, 96, 0,
False)));
- Table.States (897).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 223, 6)));
- Table.States (898).Action_List.Set_Capacity (3);
- Add_Action (Table.States (898), 10, 1052);
- Add_Action (Table.States (898), 74, Reduce, (228, 5), 2, null,
null);
- Add_Action (Table.States (898), 96, Reduce, (228, 5), 2, null,
null);
- Table.States (898).Kernel := To_Vector (((228, 34, 2, False),
(228, 34, 0, False)));
- Table.States (898).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 228, 2)));
- Table.States (899).Action_List.Set_Capacity (2);
- Add_Action (Table.States (899), (77, 83), (180, 0), 1, null, null);
- Table.States (899).Kernel := To_Vector ((0 => (180, 104, 0,
False)));
- Table.States (899).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 180, 1)));
- Table.States (900).Action_List.Set_Capacity (2);
- Add_Action (Table.States (900), (77, 83), (180, 1), 1, null, null);
- Table.States (900).Kernel := To_Vector ((0 => (180, 106, 0,
False)));
- Table.States (900).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 180, 1)));
+ Add_Action (Table.States (881), 77, Reduce, (171, 2), 3, null,
null);
+ Add_Action (Table.States (881), 83, 1039);
+ Add_Action (Table.States (881), 97, Reduce, (171, 2), 3, null,
null);
+ Table.States (881).Kernel := To_Vector (((171, 243, 1, False),
(171, 243, 0, False)));
+ Table.States (881).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 171, 3)));
+ Table.States (882).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (882), 76, Reduce, (240, 2), 1, null,
name_2_check'Access);
+ Add_Action (Table.States (882), 77, Reduce, (243, 1), 1,
null_exclusion_opt_name_type_1'Access, null);
+ Add_Action (Table.States (882), 83, Reduce, (243, 1), 1,
null_exclusion_opt_name_type_1'Access, null);
+ Add_Action (Table.States (882), 85, Reduce, (240, 2), 1, null,
name_2_check'Access);
+ Add_Action (Table.States (882), 97, Reduce, (243, 1), 1,
null_exclusion_opt_name_type_1'Access, null);
+ Add_Action (Table.States (882), 102, Reduce, (240, 2), 1, null,
name_2_check'Access);
+ Add_Action (Table.States (882), 103, Reduce, (240, 2), 1, null,
name_2_check'Access);
+ Table.States (882).Kernel := To_Vector (((240, 294, 0, True),
(243, 294, 0, False)));
+ Table.States (882).Minimal_Complete_Actions := To_Vector
(((Reduce, 240, 1), (Reduce, 243, 1)));
+ Table.States (882).Minimal_Complete_Actions_Recursive := True;
+ Table.States (883).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (883), 39, Reduce, (110, 0), 2, null,
null);
+ Add_Conflict (Table.States (883), 39, (111, 0), 2, null, null);
+ Table.States (883).Kernel := To_Vector (((110, 36, 0, False),
(111, 36, 0, False)));
+ Table.States (883).Minimal_Complete_Actions := To_Vector
(((Reduce, 110, 2), (Reduce, 111, 2)));
+ Table.States (884).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (884), (1 => 39), (110, 1), 2, null,
null);
+ Table.States (884).Kernel := To_Vector ((0 => (110, 64, 0,
False)));
+ Table.States (884).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 110, 2)));
+ Table.States (885).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (885), 36, 1040);
+ Add_Action (Table.States (885), 41, Reduce, (112, 1), 2, null,
null);
+ Add_Action (Table.States (885), 49, Reduce, (112, 1), 2, null,
null);
+ Add_Action (Table.States (885), 54, Reduce, (112, 1), 2, null,
null);
+ Table.States (885).Kernel := To_Vector (((112, 65, 1, False),
(112, 65, 0, False)));
+ Table.States (885).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 112, 2)));
+ Table.States (886).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (886), 3, 122);
+ Add_Action (Table.States (886), 39, 123);
+ Add_Action (Table.States (886), 40, 477);
+ Add_Action (Table.States (886), 41, 125);
+ Add_Action (Table.States (886), 76, 127);
+ Add_Action (Table.States (886), 79, 31);
+ Add_Action (Table.States (886), 95, 128);
+ Add_Action (Table.States (886), 96, 129);
+ Add_Action (Table.States (886), 104, 130);
+ Add_Action (Table.States (886), 105, 120);
+ Add_Action (Table.States (886), 106, 34);
+ Add_Action (Table.States (886), 107, 35);
+ Table.States (886).Goto_List.Set_Capacity (17);
+ Add_Goto (Table.States (886), 118, 131);
+ Add_Goto (Table.States (886), 129, 42);
+ Add_Goto (Table.States (886), 168, 784);
+ Add_Goto (Table.States (886), 169, 1041);
+ Add_Goto (Table.States (886), 198, 134);
+ Add_Goto (Table.States (886), 226, 1042);
+ Add_Goto (Table.States (886), 227, 1043);
+ Add_Goto (Table.States (886), 240, 1044);
+ Add_Goto (Table.States (886), 259, 136);
+ Add_Goto (Table.States (886), 273, 93);
+ Add_Goto (Table.States (886), 278, 481);
+ Add_Goto (Table.States (886), 294, 98);
+ Add_Goto (Table.States (886), 302, 482);
+ Add_Goto (Table.States (886), 315, 483);
+ Add_Goto (Table.States (886), 321, 145);
+ Add_Goto (Table.States (886), 322, 146);
+ Add_Goto (Table.States (886), 331, 147);
+ Table.States (886).Kernel := To_Vector (((121, 76, 6, False),
(121, 76, 6, False)));
+ Table.States (886).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (887).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (887), 20, 1045);
+ Add_Action (Table.States (887), 53, 1046);
+ Add_Action (Table.States (887), 74, Reduce, (280, 1), 0, null,
null);
+ Add_Action (Table.States (887), 97, Reduce, (280, 1), 0, null,
null);
+ Table.States (887).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (887), 280, 1047);
+ Table.States (887).Kernel := To_Vector (((327, 193, 1, False),
(327, 193, 0, False)));
+ Table.States (887).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 280, 0)));
+ Table.States (888).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (888), 53, 1046);
+ Add_Action (Table.States (888), 74, Reduce, (280, 1), 0, null,
null);
+ Add_Action (Table.States (888), 97, Reduce, (280, 1), 0, null,
null);
+ Table.States (888).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (888), 280, 1048);
+ Table.States (888).Kernel := To_Vector ((0 => (327, 193, 0,
False)));
+ Table.States (888).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 280, 0)));
+ Table.States (889).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (889), 10, 1049);
+ Add_Action (Table.States (889), 74, Reduce, (229, 4), 2, null,
null);
+ Add_Action (Table.States (889), 97, Reduce, (229, 4), 2, null,
null);
+ Table.States (889).Kernel := To_Vector (((229, 34, 2, False),
(229, 34, 0, False)));
+ Table.States (889).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 229, 2)));
+ Table.States (890).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (890), (74, 97), (327, 2), 2, null, null);
+ Table.States (890).Kernel := To_Vector ((0 => (327, 193, 0,
False)));
+ Table.States (890).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 327, 2)));
+ Table.States (891).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (891), (74, 97), (281, 1), 2, null, null);
+ Table.States (891).Kernel := To_Vector ((0 => (281, 54, 0,
False)));
+ Table.States (891).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 281, 2)));
+ Table.States (892).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (892), 10, 1050);
+ Add_Action (Table.States (892), 74, Reduce, (229, 6), 2, null,
null);
+ Add_Action (Table.States (892), 97, Reduce, (229, 6), 2, null,
null);
+ Table.States (892).Kernel := To_Vector (((229, 34, 2, False),
(229, 34, 0, False)));
+ Table.States (892).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 229, 2)));
+ Table.States (893).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (893), 86, 1051);
+ Table.States (893).Kernel := To_Vector ((0 => (327, 302, 2,
False)));
+ Table.States (893).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 86, 1051)));
+ Table.States (894).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (894), 35, Reduce, (165, 1), 0, null,
null);
+ Add_Action (Table.States (894), 105, 1052);
+ Add_Action (Table.States (894), 106, 1053);
+ Table.States (894).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (894), 164, 1054);
+ Add_Goto (Table.States (894), 165, 1055);
+ Table.States (894).Kernel := To_Vector ((0 => (328, 15, 6,
False)));
+ Table.States (894).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 165, 0)));
+ Table.States (895).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (895), 97, 1056);
+ Table.States (895).Kernel := To_Vector ((0 => (150, 41, 1,
False)));
+ Table.States (895).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1056)));
+ Table.States (896).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (896), (15, 24, 28, 72, 105), (149, 1),
1, null, null);
+ Table.States (896).Kernel := To_Vector ((0 => (149, 122, 0,
False)));
+ Table.States (896).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 149, 1)));
+ Table.States (897).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (897), (15, 24, 28, 72, 105), (149, 0),
1, null, null);
+ Table.States (897).Kernel := To_Vector ((0 => (149, 147, 0,
False)));
+ Table.States (897).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 149, 1)));
+ Table.States (898).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (898), (15, 24, 28, 72, 105), (150, 2),
1, null, null);
+ Table.States (898).Kernel := To_Vector ((0 => (150, 149, 0,
False)));
+ Table.States (898).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 150, 1)));
+ Table.States (899).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (899), 15, 894);
+ Add_Action (Table.States (899), 24, Reduce, (151, 0), 1, null,
null);
+ Add_Action (Table.States (899), 28, 184);
+ Add_Action (Table.States (899), 72, Reduce, (151, 0), 1, null,
null);
+ Add_Action (Table.States (899), 105, 165);
+ Table.States (899).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (899), 122, 896);
+ Add_Goto (Table.States (899), 128, 41);
+ Add_Goto (Table.States (899), 147, 897);
+ Add_Goto (Table.States (899), 149, 1057);
+ Add_Goto (Table.States (899), 183, 56);
+ Add_Goto (Table.States (899), 220, 901);
+ Add_Goto (Table.States (899), 282, 95);
+ Add_Goto (Table.States (899), 328, 1058);
+ Table.States (899).Kernel := To_Vector (((150, 150, 4, True),
(150, 150, 7, True), (151, 150, 0, False)));
+ Table.States (899).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 151, 1)));
+ Table.States (900).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (900), 24, 1059);
+ Table.States (900).Kernel := To_Vector ((0 => (281, 151, 2,
False)));
+ Table.States (900).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1059)));
Table.States (901).Action_List.Set_Capacity (2);
- Add_Action (Table.States (901), (77, 83), (181, 1), 1, null, null);
- Table.States (901).Kernel := To_Vector ((0 => (181, 180, 0,
False)));
- Table.States (901).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 181, 1)));
- Table.States (902).Action_List.Set_Capacity (2);
- Add_Action (Table.States (902), 77, 1053);
- Add_Action (Table.States (902), 83, 1054);
- Table.States (902).Kernel := To_Vector (((181, 181, 2, True),
(183, 181, 1, False)));
- Table.States (902).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 1053)));
- Table.States (903).Action_List.Set_Capacity (4);
- Add_Action (Table.States (903), 40, 483);
- Add_Action (Table.States (903), 104, 119);
- Add_Action (Table.States (903), 105, 33);
- Add_Action (Table.States (903), 106, 34);
- Table.States (903).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (903), 128, 41);
- Add_Goto (Table.States (903), 239, 484);
- Add_Goto (Table.States (903), 272, 92);
- Add_Goto (Table.States (903), 293, 97);
- Add_Goto (Table.States (903), 314, 1055);
- Table.States (903).Kernel := To_Vector ((0 => (259, 39, 4,
False)));
- Table.States (903).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
+ Add_Action (Table.States (901), 82, 1060);
+ Add_Action (Table.States (901), 84, 235);
+ Table.States (901).Kernel := To_Vector (((147, 220, 4, False),
(147, 220, 3, False), (220, 220, 2, True)));
+ Table.States (901).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 82, 1060)));
+ Table.States (902).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (902), (15, 24, 28, 72, 105), (150, 3),
1, null, null);
+ Table.States (902).Kernel := To_Vector ((0 => (150, 328, 0,
False)));
+ Table.States (902).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 150, 1)));
+ Table.States (903).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (903), 10, 1061);
+ Add_Action (Table.States (903), 74, Reduce, (229, 7), 2, null,
null);
+ Add_Action (Table.States (903), 97, Reduce, (229, 7), 2, null,
null);
+ Table.States (903).Kernel := To_Vector (((229, 34, 2, False),
(229, 34, 0, False)));
+ Table.States (903).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 229, 2)));
Table.States (904).Action_List.Set_Capacity (3);
- Add_Action (Table.States (904), 104, 119);
- Add_Action (Table.States (904), 105, 33);
- Add_Action (Table.States (904), 106, 34);
- Table.States (904).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (904), 128, 41);
- Add_Goto (Table.States (904), 239, 1056);
- Add_Goto (Table.States (904), 272, 92);
- Add_Goto (Table.States (904), 293, 97);
- Table.States (904).Kernel := To_Vector (((162, 39, 4, False),
(162, 39, 1, False)));
- Table.States (904).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (905).Action_List.Set_Capacity (2);
- Add_Action (Table.States (905), 74, 337);
- Add_Action (Table.States (905), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (905).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (905), 122, 1057);
- Table.States (905).Kernel := To_Vector ((0 => (260, 49, 1,
False)));
- Table.States (905).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (906).Action_List.Set_Capacity (2);
- Add_Action (Table.States (906), (74, 96), (326, 7), 2, null, null);
- Table.States (906).Kernel := To_Vector ((0 => (326, 280, 0,
False)));
- Table.States (906).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 326, 2)));
- Table.States (907).Action_List.Set_Capacity (1);
- Add_Action (Table.States (907), 96, 1058);
- Table.States (907).Kernel := To_Vector ((0 => (206, 122, 1,
False)));
- Table.States (907).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1058)));
- Table.States (908).Action_List.Set_Capacity (1);
- Add_Action (Table.States (908), 96, 1059);
- Table.States (908).Kernel := To_Vector ((0 => (245, 122, 1,
False)));
- Table.States (908).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1059)));
- Table.States (909).Action_List.Set_Capacity (1);
- Add_Action (Table.States (909), 96, 1060);
- Table.States (909).Kernel := To_Vector ((0 => (245, 122, 1,
False)));
- Table.States (909).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1060)));
- Table.States (910).Action_List.Set_Capacity (11);
- Add_Action (Table.States (910), 21, Reduce, (114, 2), 4,
access_definition_2'Access, null);
- Add_Action (Table.States (910), 35, Reduce, (114, 2), 4,
access_definition_2'Access, null);
- Add_Action (Table.States (910), 56, Reduce, (114, 2), 4,
access_definition_2'Access, null);
- Add_Action (Table.States (910), 74, Reduce, (114, 2), 4,
access_definition_2'Access, null);
- Add_Action (Table.States (910), 76, 235);
- Add_Action (Table.States (910), 77, Reduce, (114, 2), 4,
access_definition_2'Access, null);
- Add_Action (Table.States (910), 82, Reduce, (114, 2), 4,
access_definition_2'Access, null);
- Add_Action (Table.States (910), 84, 237);
- Add_Action (Table.States (910), 96, Reduce, (114, 2), 4,
access_definition_2'Access, null);
- Add_Action (Table.States (910), 101, 239);
- Add_Action (Table.States (910), 102, 240);
- Table.States (910).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (910), 115, 241);
- Add_Goto (Table.States (910), 322, 242);
- Table.States (910).Kernel := To_Vector (((114, 239, 0, False),
(128, 239, 2, True), (239, 239, 5, True),
- (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (910).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 114, 4)));
- Table.States (911).Action_List.Set_Capacity (2);
- Add_Action (Table.States (911), 58, 317);
- Add_Action (Table.States (911), 76, 431);
- Table.States (911).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (911), 199, 319);
- Add_Goto (Table.States (911), 252, 1061);
- Add_Goto (Table.States (911), 291, 321);
- Table.States (911).Kernel := To_Vector ((0 => (114, 29, 1, True)));
- Table.States (911).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 58, 317)));
- Table.States (911).Minimal_Complete_Actions_Recursive := True;
- Table.States (912).Action_List.Set_Capacity (8);
- Add_Action (Table.States (912), 21, Reduce, (253, 1), 0, null,
null);
- Add_Action (Table.States (912), 35, Reduce, (253, 1), 0, null,
null);
- Add_Action (Table.States (912), 56, Reduce, (253, 1), 0, null,
null);
- Add_Action (Table.States (912), 74, Reduce, (253, 1), 0, null,
null);
- Add_Action (Table.States (912), 76, 431);
- Add_Action (Table.States (912), 77, Reduce, (253, 1), 0, null,
null);
- Add_Action (Table.States (912), 82, Reduce, (253, 1), 0, null,
null);
- Add_Action (Table.States (912), 96, Reduce, (253, 1), 0, null,
null);
- Table.States (912).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (912), 199, 344);
- Add_Goto (Table.States (912), 253, 1062);
- Table.States (912).Kernel := To_Vector ((0 => (114, 50, 0,
False)));
- Table.States (912).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 253, 0)));
- Table.States (913).Action_List.Set_Capacity (6);
- Add_Action (Table.States (913), 74, 337);
- Add_Action (Table.States (913), 76, 235);
- Add_Action (Table.States (913), 84, 237);
- Add_Action (Table.States (913), 96, Reduce, (122, 1), 0, null,
null);
- Add_Action (Table.States (913), 101, 239);
- Add_Action (Table.States (913), 102, 240);
- Table.States (913).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (913), 115, 241);
- Add_Goto (Table.States (913), 122, 1063);
- Add_Goto (Table.States (913), 322, 242);
- Table.States (913).Kernel := To_Vector (((128, 239, 2, True),
(239, 239, 5, True), (239, 239, 2, True),
- (245, 239, 1, False), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (913).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (914).Action_List.Set_Capacity (46);
- Add_Action (Table.States (914), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (133, 1), 6, block_statement_1'Access,
block_statement_1_check'Access);
- Table.States (914).Kernel := To_Vector ((0 => (133, 96, 0,
False)));
- Table.States (914).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 133, 6)));
- Table.States (915).Action_List.Set_Capacity (2);
- Add_Action (Table.States (915), (79, 87), (184, 1), 1, null, null);
- Table.States (915).Kernel := To_Vector ((0 => (184, 44, 0,
False)));
- Table.States (915).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 184, 1)));
- Table.States (916).Action_List.Set_Capacity (7);
- Add_Action (Table.States (916), 76, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (916), 79, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (916), 81, 1064);
- Add_Action (Table.States (916), 84, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (916), 87, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (916), 101, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (916), 102, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Table.States (916).Kernel := To_Vector (((187, 104, 3, False),
(239, 104, 0, False)));
- Table.States (916).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 239, 1)));
- Table.States (917).Action_List.Set_Capacity (2);
- Add_Action (Table.States (917), (79, 87), (185, 1), 1, null, null);
- Table.States (917).Kernel := To_Vector ((0 => (185, 184, 0,
False)));
- Table.States (917).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 185, 1)));
- Table.States (918).Action_List.Set_Capacity (2);
- Add_Action (Table.States (918), 79, 1065);
- Add_Action (Table.States (918), 87, 1066);
- Table.States (918).Kernel := To_Vector (((185, 185, 2, True),
(187, 185, 1, False)));
- Table.States (918).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 87, 1066)));
- Table.States (919).Action_List.Set_Capacity (6);
- Add_Action (Table.States (919), 76, 235);
- Add_Action (Table.States (919), 79, Reduce, (184, 0), 1, null,
null);
- Add_Action (Table.States (919), 84, 237);
- Add_Action (Table.States (919), 87, Reduce, (184, 0), 1, null,
null);
- Add_Action (Table.States (919), 101, 239);
- Add_Action (Table.States (919), 102, 240);
- Table.States (919).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (919), 115, 241);
- Add_Goto (Table.States (919), 322, 242);
- Table.States (919).Kernel := To_Vector (((128, 239, 2, True),
(184, 239, 0, False), (239, 239, 5, True),
- (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (919).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 184, 1)));
- Table.States (920).Action_List.Set_Capacity (2);
- Add_Action (Table.States (920), (24, 72), (188, 0), 2,
exception_handler_list_0'Access, null);
- Table.States (920).Kernel := To_Vector ((0 => (188, 187, 0,
True)));
- Table.States (920).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 188, 2)));
- Table.States (920).Minimal_Complete_Actions_Recursive := True;
- Table.States (921).Action_List.Set_Capacity (2);
- Add_Action (Table.States (921), 96, Reduce, (220, 1), 0, null,
null);
- Add_Action (Table.States (921), 104, 149);
- Table.States (921).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (921), 220, 1067);
- Table.States (921).Kernel := To_Vector ((0 => (133, 24, 1,
False)));
- Table.States (921).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 220, 0)));
- Table.States (922).Action_List.Set_Capacity (1);
- Add_Action (Table.States (922), 96, 1068);
- Table.States (922).Kernel := To_Vector ((0 => (232, 220, 1,
False)));
- Table.States (922).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1068)));
+ Add_Action (Table.States (904), (41, 49, 54), (112, 2), 2, null,
null);
+ Table.States (904).Kernel := To_Vector ((0 => (112, 36, 0,
False)));
+ Table.States (904).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 112, 2)));
+ Table.States (905).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (905), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (224, 0), 6,
+ incomplete_type_declaration_0'Access, null);
+ Table.States (905).Kernel := To_Vector ((0 => (224, 97, 0,
False)));
+ Table.States (905).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 224, 6)));
+ Table.States (906).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (906), 10, 1062);
+ Add_Action (Table.States (906), 74, Reduce, (229, 5), 2, null,
null);
+ Add_Action (Table.States (906), 97, Reduce, (229, 5), 2, null,
null);
+ Table.States (906).Kernel := To_Vector (((229, 34, 2, False),
(229, 34, 0, False)));
+ Table.States (906).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 229, 2)));
+ Table.States (907).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (907), (77, 84), (181, 0), 1, null, null);
+ Table.States (907).Kernel := To_Vector ((0 => (181, 105, 0,
False)));
+ Table.States (907).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 181, 1)));
+ Table.States (908).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (908), (77, 84), (181, 1), 1, null, null);
+ Table.States (908).Kernel := To_Vector ((0 => (181, 107, 0,
False)));
+ Table.States (908).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 181, 1)));
+ Table.States (909).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (909), (77, 84), (182, 1), 1, null, null);
+ Table.States (909).Kernel := To_Vector ((0 => (182, 181, 0,
False)));
+ Table.States (909).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 182, 1)));
+ Table.States (910).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (910), 77, 1063);
+ Add_Action (Table.States (910), 84, 1064);
+ Table.States (910).Kernel := To_Vector (((182, 182, 2, True),
(184, 182, 1, False)));
+ Table.States (910).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 1063)));
+ Table.States (911).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (911), 40, 486);
+ Add_Action (Table.States (911), 79, 31);
+ Add_Action (Table.States (911), 105, 120);
+ Add_Action (Table.States (911), 106, 34);
+ Add_Action (Table.States (911), 107, 35);
+ Table.States (911).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (911), 129, 42);
+ Add_Goto (Table.States (911), 240, 487);
+ Add_Goto (Table.States (911), 273, 93);
+ Add_Goto (Table.States (911), 294, 98);
+ Add_Goto (Table.States (911), 315, 1065);
+ Table.States (911).Kernel := To_Vector ((0 => (260, 39, 4,
False)));
+ Table.States (911).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (912).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (912), 79, 31);
+ Add_Action (Table.States (912), 105, 120);
+ Add_Action (Table.States (912), 106, 34);
+ Add_Action (Table.States (912), 107, 35);
+ Table.States (912).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (912), 129, 42);
+ Add_Goto (Table.States (912), 240, 1066);
+ Add_Goto (Table.States (912), 273, 93);
+ Add_Goto (Table.States (912), 294, 98);
+ Table.States (912).Kernel := To_Vector (((163, 39, 4, False),
(163, 39, 1, False)));
+ Table.States (912).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (913).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (913), 74, 338);
+ Add_Action (Table.States (913), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (913).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (913), 123, 1067);
+ Table.States (913).Kernel := To_Vector ((0 => (261, 49, 1,
False)));
+ Table.States (913).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (914).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (914), (74, 97), (327, 7), 2, null, null);
+ Table.States (914).Kernel := To_Vector ((0 => (327, 281, 0,
False)));
+ Table.States (914).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 327, 2)));
+ Table.States (915).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (915), 97, 1068);
+ Table.States (915).Kernel := To_Vector ((0 => (207, 123, 1,
False)));
+ Table.States (915).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1068)));
+ Table.States (916).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (916), 97, 1069);
+ Table.States (916).Kernel := To_Vector ((0 => (246, 123, 1,
False)));
+ Table.States (916).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1069)));
+ Table.States (917).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (917), 97, 1070);
+ Table.States (917).Kernel := To_Vector ((0 => (246, 123, 1,
False)));
+ Table.States (917).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1070)));
+ Table.States (918).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (918), 21, Reduce, (115, 2), 4,
access_definition_2'Access, null);
+ Add_Action (Table.States (918), 35, Reduce, (115, 2), 4,
access_definition_2'Access, null);
+ Add_Action (Table.States (918), 56, Reduce, (115, 2), 4,
access_definition_2'Access, null);
+ Add_Action (Table.States (918), 74, Reduce, (115, 2), 4,
access_definition_2'Access, null);
+ Add_Action (Table.States (918), 76, 236);
+ Add_Action (Table.States (918), 77, Reduce, (115, 2), 4,
access_definition_2'Access, null);
+ Add_Action (Table.States (918), 83, Reduce, (115, 2), 4,
access_definition_2'Access, null);
+ Add_Action (Table.States (918), 85, 238);
+ Add_Action (Table.States (918), 97, Reduce, (115, 2), 4,
access_definition_2'Access, null);
+ Add_Action (Table.States (918), 102, 240);
+ Add_Action (Table.States (918), 103, 241);
+ Table.States (918).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (918), 116, 242);
+ Add_Goto (Table.States (918), 323, 243);
+ Table.States (918).Kernel := To_Vector (((115, 240, 0, False),
(129, 240, 2, True), (240, 240, 5, True),
+ (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (918).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 115, 4)));
+ Table.States (919).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (919), 58, 318);
+ Add_Action (Table.States (919), 76, 432);
+ Table.States (919).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (919), 200, 320);
+ Add_Goto (Table.States (919), 253, 1071);
+ Add_Goto (Table.States (919), 292, 322);
+ Table.States (919).Kernel := To_Vector ((0 => (115, 29, 1, True)));
+ Table.States (919).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 58, 318)));
+ Table.States (919).Minimal_Complete_Actions_Recursive := True;
+ Table.States (920).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (920), 21, Reduce, (254, 1), 0, null,
null);
+ Add_Action (Table.States (920), 35, Reduce, (254, 1), 0, null,
null);
+ Add_Action (Table.States (920), 56, Reduce, (254, 1), 0, null,
null);
+ Add_Action (Table.States (920), 74, Reduce, (254, 1), 0, null,
null);
+ Add_Action (Table.States (920), 76, 432);
+ Add_Action (Table.States (920), 77, Reduce, (254, 1), 0, null,
null);
+ Add_Action (Table.States (920), 83, Reduce, (254, 1), 0, null,
null);
+ Add_Action (Table.States (920), 97, Reduce, (254, 1), 0, null,
null);
+ Table.States (920).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (920), 200, 345);
+ Add_Goto (Table.States (920), 254, 1072);
+ Table.States (920).Kernel := To_Vector ((0 => (115, 50, 0,
False)));
+ Table.States (920).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 254, 0)));
+ Table.States (921).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (921), 74, 338);
+ Add_Action (Table.States (921), 76, 236);
+ Add_Action (Table.States (921), 85, 238);
+ Add_Action (Table.States (921), 97, Reduce, (123, 1), 0, null,
null);
+ Add_Action (Table.States (921), 102, 240);
+ Add_Action (Table.States (921), 103, 241);
+ Table.States (921).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (921), 116, 242);
+ Add_Goto (Table.States (921), 123, 1073);
+ Add_Goto (Table.States (921), 323, 243);
+ Table.States (921).Kernel := To_Vector (((129, 240, 2, True),
(240, 240, 5, True), (240, 240, 2, True),
+ (246, 240, 1, False), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (921).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (922).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (922), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (134, 1), 6, block_statement_1'Access,
block_statement_1_check'Access);
+ Table.States (922).Kernel := To_Vector ((0 => (134, 97, 0,
False)));
+ Table.States (922).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 134, 6)));
Table.States (923).Action_List.Set_Capacity (2);
- Add_Action (Table.States (923), 96, Reduce, (220, 1), 0, null,
null);
- Add_Action (Table.States (923), 104, 149);
- Table.States (923).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (923), 220, 1069);
- Table.States (923).Kernel := To_Vector ((0 => (232, 37, 1,
False)));
- Table.States (923).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 220, 0)));
- Table.States (924).Action_List.Set_Capacity (40);
- Add_Action (Table.States (924), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (157, 9), 6,
+ Add_Action (Table.States (923), (80, 88), (185, 1), 1, null, null);
+ Table.States (923).Kernel := To_Vector ((0 => (185, 44, 0,
False)));
+ Table.States (923).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 185, 1)));
+ Table.States (924).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (924), 76, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (924), 80, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (924), 82, 1074);
+ Add_Action (Table.States (924), 85, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (924), 88, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (924), 102, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (924), 103, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Table.States (924).Kernel := To_Vector (((188, 105, 3, False),
(240, 105, 0, False)));
+ Table.States (924).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 240, 1)));
+ Table.States (925).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (925), (80, 88), (186, 1), 1, null, null);
+ Table.States (925).Kernel := To_Vector ((0 => (186, 185, 0,
False)));
+ Table.States (925).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 186, 1)));
+ Table.States (926).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (926), 80, 1075);
+ Add_Action (Table.States (926), 88, 1076);
+ Table.States (926).Kernel := To_Vector (((186, 186, 2, True),
(188, 186, 1, False)));
+ Table.States (926).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 88, 1076)));
+ Table.States (927).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (927), 76, 236);
+ Add_Action (Table.States (927), 80, Reduce, (185, 0), 1, null,
null);
+ Add_Action (Table.States (927), 85, 238);
+ Add_Action (Table.States (927), 88, Reduce, (185, 0), 1, null,
null);
+ Add_Action (Table.States (927), 102, 240);
+ Add_Action (Table.States (927), 103, 241);
+ Table.States (927).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (927), 116, 242);
+ Add_Goto (Table.States (927), 323, 243);
+ Table.States (927).Kernel := To_Vector (((129, 240, 2, True),
(185, 240, 0, False), (240, 240, 5, True),
+ (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (927).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 185, 1)));
+ Table.States (928).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (928), (24, 72), (189, 0), 2,
exception_handler_list_0'Access, null);
+ Table.States (928).Kernel := To_Vector ((0 => (189, 188, 0,
True)));
+ Table.States (928).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 189, 2)));
+ Table.States (928).Minimal_Complete_Actions_Recursive := True;
+ Table.States (929).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (929), 97, Reduce, (221, 1), 0, null,
null);
+ Add_Action (Table.States (929), 105, 150);
+ Table.States (929).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (929), 221, 1077);
+ Table.States (929).Kernel := To_Vector ((0 => (134, 24, 1,
False)));
+ Table.States (929).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 221, 0)));
+ Table.States (930).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (930), 97, 1078);
+ Table.States (930).Kernel := To_Vector ((0 => (233, 221, 1,
False)));
+ Table.States (930).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1078)));
+ Table.States (931).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (931), 97, Reduce, (221, 1), 0, null,
null);
+ Add_Action (Table.States (931), 105, 150);
+ Table.States (931).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (931), 221, 1079);
+ Table.States (931).Kernel := To_Vector ((0 => (233, 37, 1,
False)));
+ Table.States (931).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 221, 0)));
+ Table.States (932).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (932), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (158, 9), 6,
declaration_9'Access, null);
- Table.States (924).Kernel := To_Vector ((0 => (157, 96, 0,
False)));
- Table.States (924).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 157, 6)));
- Table.States (925).Action_List.Set_Capacity (4);
- Add_Action (Table.States (925), 7, Reduce, (241, 0), 2, null,
null);
- Add_Action (Table.States (925), 104, 119);
- Add_Action (Table.States (925), 105, 33);
- Add_Action (Table.States (925), 106, 34);
- Table.States (925).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (925), 128, 41);
- Add_Goto (Table.States (925), 239, 773);
- Add_Goto (Table.States (925), 272, 92);
- Add_Goto (Table.States (925), 293, 97);
- Table.States (925).Kernel := To_Vector (((241, 41, 0, False),
(314, 41, 5, False), (314, 41, 1, False)));
- Table.States (925).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 241, 2)));
- Table.States (926).Action_List.Set_Capacity (14);
- Add_Action (Table.States (926), 3, 121);
- Add_Action (Table.States (926), 39, 122);
- Add_Action (Table.States (926), 40, 123);
- Add_Action (Table.States (926), 41, 124);
- Add_Action (Table.States (926), 52, 125);
- Add_Action (Table.States (926), 74, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (926), 76, 126);
- Add_Action (Table.States (926), 94, 127);
- Add_Action (Table.States (926), 95, 128);
- Add_Action (Table.States (926), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (926), 103, 129);
- Add_Action (Table.States (926), 104, 119);
- Add_Action (Table.States (926), 105, 33);
- Add_Action (Table.States (926), 106, 34);
- Table.States (926).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (926), 117, 130);
- Add_Goto (Table.States (926), 128, 41);
- Add_Goto (Table.States (926), 191, 131);
- Add_Goto (Table.States (926), 192, 1070);
- Add_Goto (Table.States (926), 197, 133);
- Add_Goto (Table.States (926), 239, 134);
- Add_Goto (Table.States (926), 258, 135);
- Add_Goto (Table.States (926), 272, 92);
- Add_Goto (Table.States (926), 275, 136);
- Add_Goto (Table.States (926), 282, 137);
- Add_Goto (Table.States (926), 283, 138);
- Add_Goto (Table.States (926), 284, 139);
- Add_Goto (Table.States (926), 285, 140);
- Add_Goto (Table.States (926), 286, 141);
- Add_Goto (Table.States (926), 287, 142);
- Add_Goto (Table.States (926), 293, 97);
- Add_Goto (Table.States (926), 301, 143);
- Add_Goto (Table.States (926), 320, 144);
- Add_Goto (Table.States (926), 321, 145);
- Add_Goto (Table.States (926), 330, 146);
- Table.States (926).Kernel := To_Vector ((0 => (244, 82, 1,
False)));
- Table.States (926).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (927).Action_List.Set_Capacity (1);
- Add_Action (Table.States (927), 96, 1071);
- Table.States (927).Kernel := To_Vector ((0 => (244, 122, 1,
False)));
- Table.States (927).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1071)));
- Table.States (928).Action_List.Set_Capacity (14);
- Add_Action (Table.States (928), 3, 121);
- Add_Action (Table.States (928), 39, 122);
- Add_Action (Table.States (928), 40, 123);
- Add_Action (Table.States (928), 41, 124);
- Add_Action (Table.States (928), 52, 125);
- Add_Action (Table.States (928), 74, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (928), 76, 126);
- Add_Action (Table.States (928), 94, 127);
- Add_Action (Table.States (928), 95, 128);
- Add_Action (Table.States (928), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (928), 103, 129);
- Add_Action (Table.States (928), 104, 119);
- Add_Action (Table.States (928), 105, 33);
- Add_Action (Table.States (928), 106, 34);
- Table.States (928).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (928), 117, 130);
- Add_Goto (Table.States (928), 128, 41);
- Add_Goto (Table.States (928), 191, 131);
- Add_Goto (Table.States (928), 192, 1072);
- Add_Goto (Table.States (928), 197, 133);
- Add_Goto (Table.States (928), 239, 134);
- Add_Goto (Table.States (928), 258, 135);
- Add_Goto (Table.States (928), 272, 92);
- Add_Goto (Table.States (928), 275, 136);
- Add_Goto (Table.States (928), 282, 137);
- Add_Goto (Table.States (928), 283, 138);
- Add_Goto (Table.States (928), 284, 139);
- Add_Goto (Table.States (928), 285, 140);
- Add_Goto (Table.States (928), 286, 141);
- Add_Goto (Table.States (928), 287, 142);
- Add_Goto (Table.States (928), 293, 97);
- Add_Goto (Table.States (928), 301, 143);
- Add_Goto (Table.States (928), 320, 144);
- Add_Goto (Table.States (928), 321, 145);
- Add_Goto (Table.States (928), 330, 146);
- Table.States (928).Kernel := To_Vector ((0 => (244, 82, 1,
False)));
- Table.States (928).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (929).Action_List.Set_Capacity (1);
- Add_Action (Table.States (929), 96, 1073);
- Table.States (929).Kernel := To_Vector ((0 => (244, 122, 1,
False)));
- Table.States (929).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1073)));
- Table.States (930).Action_List.Set_Capacity (14);
- Add_Action (Table.States (930), 3, 121);
- Add_Action (Table.States (930), 39, 122);
- Add_Action (Table.States (930), 40, 123);
- Add_Action (Table.States (930), 41, 124);
- Add_Action (Table.States (930), 52, 125);
- Add_Action (Table.States (930), 74, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (930), 76, 126);
- Add_Action (Table.States (930), 94, 127);
- Add_Action (Table.States (930), 95, 128);
- Add_Action (Table.States (930), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (930), 103, 129);
- Add_Action (Table.States (930), 104, 119);
- Add_Action (Table.States (930), 105, 33);
- Add_Action (Table.States (930), 106, 34);
- Table.States (930).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (930), 117, 130);
- Add_Goto (Table.States (930), 128, 41);
- Add_Goto (Table.States (930), 191, 131);
- Add_Goto (Table.States (930), 192, 1074);
- Add_Goto (Table.States (930), 197, 133);
- Add_Goto (Table.States (930), 239, 134);
- Add_Goto (Table.States (930), 258, 135);
- Add_Goto (Table.States (930), 272, 92);
- Add_Goto (Table.States (930), 275, 136);
- Add_Goto (Table.States (930), 282, 137);
- Add_Goto (Table.States (930), 283, 138);
- Add_Goto (Table.States (930), 284, 139);
- Add_Goto (Table.States (930), 285, 140);
- Add_Goto (Table.States (930), 286, 141);
- Add_Goto (Table.States (930), 287, 142);
- Add_Goto (Table.States (930), 293, 97);
- Add_Goto (Table.States (930), 301, 143);
- Add_Goto (Table.States (930), 320, 144);
- Add_Goto (Table.States (930), 321, 145);
- Add_Goto (Table.States (930), 330, 146);
- Table.States (930).Kernel := To_Vector ((0 => (244, 82, 1,
False)));
- Table.States (930).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (931).Action_List.Set_Capacity (1);
- Add_Action (Table.States (931), 96, 1075);
- Table.States (931).Kernel := To_Vector ((0 => (244, 122, 1,
False)));
- Table.States (931).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1075)));
- Table.States (932).Action_List.Set_Capacity (63);
- Add_Action (Table.States (932), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
- 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
- 88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104,
105, 106), (129, 0), 4, null, null);
- Table.States (932).Kernel := To_Vector ((0 => (129, 77, 0,
False)));
- Table.States (932).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 129, 4)));
- Table.States (933).Action_List.Set_Capacity (3);
- Add_Action (Table.States (933), 74, Reduce, (253, 1), 0, null,
null);
- Add_Action (Table.States (933), 76, 431);
- Add_Action (Table.States (933), 96, Reduce, (253, 1), 0, null,
null);
- Table.States (933).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (933), 199, 344);
- Add_Goto (Table.States (933), 253, 1076);
- Table.States (933).Kernel := To_Vector ((0 => (179, 77, 1,
False)));
- Table.States (933).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 253, 0)));
- Table.States (934).Action_List.Set_Capacity (40);
- Add_Action (Table.States (934), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (179, 1), 6,
+ Table.States (932).Kernel := To_Vector ((0 => (158, 97, 0,
False)));
+ Table.States (932).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 158, 6)));
+ Table.States (933).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (933), 7, Reduce, (242, 0), 2, null,
null);
+ Add_Action (Table.States (933), 79, 31);
+ Add_Action (Table.States (933), 105, 120);
+ Add_Action (Table.States (933), 106, 34);
+ Add_Action (Table.States (933), 107, 35);
+ Table.States (933).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (933), 129, 42);
+ Add_Goto (Table.States (933), 240, 781);
+ Add_Goto (Table.States (933), 273, 93);
+ Add_Goto (Table.States (933), 294, 98);
+ Table.States (933).Kernel := To_Vector (((242, 41, 0, False),
(315, 41, 5, False), (315, 41, 1, False)));
+ Table.States (933).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 242, 2)));
+ Table.States (934).Action_List.Set_Capacity (15);
+ Add_Action (Table.States (934), 3, 122);
+ Add_Action (Table.States (934), 39, 123);
+ Add_Action (Table.States (934), 40, 124);
+ Add_Action (Table.States (934), 41, 125);
+ Add_Action (Table.States (934), 52, 126);
+ Add_Action (Table.States (934), 74, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (934), 76, 127);
+ Add_Action (Table.States (934), 79, 31);
+ Add_Action (Table.States (934), 95, 128);
+ Add_Action (Table.States (934), 96, 129);
+ Add_Action (Table.States (934), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (934), 104, 130);
+ Add_Action (Table.States (934), 105, 120);
+ Add_Action (Table.States (934), 106, 34);
+ Add_Action (Table.States (934), 107, 35);
+ Table.States (934).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (934), 118, 131);
+ Add_Goto (Table.States (934), 129, 42);
+ Add_Goto (Table.States (934), 192, 132);
+ Add_Goto (Table.States (934), 193, 1080);
+ Add_Goto (Table.States (934), 198, 134);
+ Add_Goto (Table.States (934), 240, 135);
+ Add_Goto (Table.States (934), 259, 136);
+ Add_Goto (Table.States (934), 273, 93);
+ Add_Goto (Table.States (934), 276, 137);
+ Add_Goto (Table.States (934), 283, 138);
+ Add_Goto (Table.States (934), 284, 139);
+ Add_Goto (Table.States (934), 285, 140);
+ Add_Goto (Table.States (934), 286, 141);
+ Add_Goto (Table.States (934), 287, 142);
+ Add_Goto (Table.States (934), 288, 143);
+ Add_Goto (Table.States (934), 294, 98);
+ Add_Goto (Table.States (934), 302, 144);
+ Add_Goto (Table.States (934), 321, 145);
+ Add_Goto (Table.States (934), 322, 146);
+ Add_Goto (Table.States (934), 331, 147);
+ Table.States (934).Kernel := To_Vector ((0 => (245, 83, 1,
False)));
+ Table.States (934).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (935).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (935), 97, 1081);
+ Table.States (935).Kernel := To_Vector ((0 => (245, 123, 1,
False)));
+ Table.States (935).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1081)));
+ Table.States (936).Action_List.Set_Capacity (15);
+ Add_Action (Table.States (936), 3, 122);
+ Add_Action (Table.States (936), 39, 123);
+ Add_Action (Table.States (936), 40, 124);
+ Add_Action (Table.States (936), 41, 125);
+ Add_Action (Table.States (936), 52, 126);
+ Add_Action (Table.States (936), 74, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (936), 76, 127);
+ Add_Action (Table.States (936), 79, 31);
+ Add_Action (Table.States (936), 95, 128);
+ Add_Action (Table.States (936), 96, 129);
+ Add_Action (Table.States (936), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (936), 104, 130);
+ Add_Action (Table.States (936), 105, 120);
+ Add_Action (Table.States (936), 106, 34);
+ Add_Action (Table.States (936), 107, 35);
+ Table.States (936).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (936), 118, 131);
+ Add_Goto (Table.States (936), 129, 42);
+ Add_Goto (Table.States (936), 192, 132);
+ Add_Goto (Table.States (936), 193, 1082);
+ Add_Goto (Table.States (936), 198, 134);
+ Add_Goto (Table.States (936), 240, 135);
+ Add_Goto (Table.States (936), 259, 136);
+ Add_Goto (Table.States (936), 273, 93);
+ Add_Goto (Table.States (936), 276, 137);
+ Add_Goto (Table.States (936), 283, 138);
+ Add_Goto (Table.States (936), 284, 139);
+ Add_Goto (Table.States (936), 285, 140);
+ Add_Goto (Table.States (936), 286, 141);
+ Add_Goto (Table.States (936), 287, 142);
+ Add_Goto (Table.States (936), 288, 143);
+ Add_Goto (Table.States (936), 294, 98);
+ Add_Goto (Table.States (936), 302, 144);
+ Add_Goto (Table.States (936), 321, 145);
+ Add_Goto (Table.States (936), 322, 146);
+ Add_Goto (Table.States (936), 331, 147);
+ Table.States (936).Kernel := To_Vector ((0 => (245, 83, 1,
False)));
+ Table.States (936).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ end Subr_16;
+ procedure Subr_17
+ is begin
+ Table.States (937).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (937), 97, 1083);
+ Table.States (937).Kernel := To_Vector ((0 => (245, 123, 1,
False)));
+ Table.States (937).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1083)));
+ Table.States (938).Action_List.Set_Capacity (15);
+ Add_Action (Table.States (938), 3, 122);
+ Add_Action (Table.States (938), 39, 123);
+ Add_Action (Table.States (938), 40, 124);
+ Add_Action (Table.States (938), 41, 125);
+ Add_Action (Table.States (938), 52, 126);
+ Add_Action (Table.States (938), 74, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (938), 76, 127);
+ Add_Action (Table.States (938), 79, 31);
+ Add_Action (Table.States (938), 95, 128);
+ Add_Action (Table.States (938), 96, 129);
+ Add_Action (Table.States (938), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (938), 104, 130);
+ Add_Action (Table.States (938), 105, 120);
+ Add_Action (Table.States (938), 106, 34);
+ Add_Action (Table.States (938), 107, 35);
+ Table.States (938).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (938), 118, 131);
+ Add_Goto (Table.States (938), 129, 42);
+ Add_Goto (Table.States (938), 192, 132);
+ Add_Goto (Table.States (938), 193, 1084);
+ Add_Goto (Table.States (938), 198, 134);
+ Add_Goto (Table.States (938), 240, 135);
+ Add_Goto (Table.States (938), 259, 136);
+ Add_Goto (Table.States (938), 273, 93);
+ Add_Goto (Table.States (938), 276, 137);
+ Add_Goto (Table.States (938), 283, 138);
+ Add_Goto (Table.States (938), 284, 139);
+ Add_Goto (Table.States (938), 285, 140);
+ Add_Goto (Table.States (938), 286, 141);
+ Add_Goto (Table.States (938), 287, 142);
+ Add_Goto (Table.States (938), 288, 143);
+ Add_Goto (Table.States (938), 294, 98);
+ Add_Goto (Table.States (938), 302, 144);
+ Add_Goto (Table.States (938), 321, 145);
+ Add_Goto (Table.States (938), 322, 146);
+ Add_Goto (Table.States (938), 331, 147);
+ Table.States (938).Kernel := To_Vector ((0 => (245, 83, 1,
False)));
+ Table.States (938).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (939).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (939), 97, 1085);
+ Table.States (939).Kernel := To_Vector ((0 => (245, 123, 1,
False)));
+ Table.States (939).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1085)));
+ Table.States (940).Action_List.Set_Capacity (64);
+ Add_Action (Table.States (940), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+ 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
105, 106, 107), (130, 0), 4, null, null);
+ Table.States (940).Kernel := To_Vector ((0 => (130, 77, 0,
False)));
+ Table.States (940).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 130, 4)));
+ Table.States (941).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (941), 74, Reduce, (254, 1), 0, null,
null);
+ Add_Action (Table.States (941), 76, 432);
+ Add_Action (Table.States (941), 97, Reduce, (254, 1), 0, null,
null);
+ Table.States (941).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (941), 200, 345);
+ Add_Goto (Table.States (941), 254, 1086);
+ Table.States (941).Kernel := To_Vector ((0 => (180, 77, 1,
False)));
+ Table.States (941).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 254, 0)));
+ Table.States (942).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (942), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (180, 1), 6,
entry_declaration_1'Access, null);
- Table.States (934).Kernel := To_Vector ((0 => (179, 96, 0,
False)));
- Table.States (934).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 179, 6)));
- Table.States (935).Action_List.Set_Capacity (6);
- Add_Action (Table.States (935), 74, 337);
- Add_Action (Table.States (935), 76, 235);
- Add_Action (Table.States (935), 84, 237);
- Add_Action (Table.States (935), 96, Reduce, (122, 1), 0, null,
null);
- Add_Action (Table.States (935), 101, 239);
- Add_Action (Table.States (935), 102, 240);
- Table.States (935).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (935), 115, 241);
- Add_Goto (Table.States (935), 122, 1077);
- Add_Goto (Table.States (935), 322, 242);
- Table.States (935).Kernel := To_Vector (((128, 239, 2, True),
(213, 239, 1, False), (239, 239, 5, True),
- (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (935).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (936).Action_List.Set_Capacity (6);
- Add_Action (Table.States (936), 74, 337);
- Add_Action (Table.States (936), 76, 235);
- Add_Action (Table.States (936), 84, 237);
- Add_Action (Table.States (936), 96, Reduce, (122, 1), 0, null,
null);
- Add_Action (Table.States (936), 101, 239);
- Add_Action (Table.States (936), 102, 240);
- Table.States (936).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (936), 115, 241);
- Add_Goto (Table.States (936), 122, 1078);
- Add_Goto (Table.States (936), 322, 242);
- Table.States (936).Kernel := To_Vector (((128, 239, 2, True),
(213, 239, 1, False), (239, 239, 5, True),
- (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (936).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (937).Action_List.Set_Capacity (2);
- Add_Action (Table.States (937), (74, 96), (256, 0), 3,
paren_expression_0'Access, null);
- Table.States (937).Kernel := To_Vector ((0 => (256, 77, 0,
False)));
- Table.States (937).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 256, 3)));
- Table.States (938).Action_List.Set_Capacity (40);
- Add_Action (Table.States (938), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (193, 0), 6,
+ Table.States (942).Kernel := To_Vector ((0 => (180, 97, 0,
False)));
+ Table.States (942).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 180, 6)));
+ Table.States (943).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (943), 74, 338);
+ Add_Action (Table.States (943), 76, 236);
+ Add_Action (Table.States (943), 85, 238);
+ Add_Action (Table.States (943), 97, Reduce, (123, 1), 0, null,
null);
+ Add_Action (Table.States (943), 102, 240);
+ Add_Action (Table.States (943), 103, 241);
+ Table.States (943).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (943), 116, 242);
+ Add_Goto (Table.States (943), 123, 1087);
+ Add_Goto (Table.States (943), 323, 243);
+ Table.States (943).Kernel := To_Vector (((129, 240, 2, True),
(214, 240, 1, False), (240, 240, 5, True),
+ (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (943).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (944).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (944), 74, 338);
+ Add_Action (Table.States (944), 76, 236);
+ Add_Action (Table.States (944), 85, 238);
+ Add_Action (Table.States (944), 97, Reduce, (123, 1), 0, null,
null);
+ Add_Action (Table.States (944), 102, 240);
+ Add_Action (Table.States (944), 103, 241);
+ Table.States (944).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (944), 116, 242);
+ Add_Goto (Table.States (944), 123, 1088);
+ Add_Goto (Table.States (944), 323, 243);
+ Table.States (944).Kernel := To_Vector (((129, 240, 2, True),
(214, 240, 1, False), (240, 240, 5, True),
+ (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (944).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (945).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (945), (74, 97), (257, 0), 3,
paren_expression_0'Access, null);
+ Table.States (945).Kernel := To_Vector ((0 => (257, 77, 0,
False)));
+ Table.States (945).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 257, 3)));
+ Table.States (946).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (946), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (194, 0), 6,
expression_function_declaration_0'Access, null);
- Table.States (938).Kernel := To_Vector ((0 => (193, 96, 0,
False)));
- Table.States (938).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 6)));
- Table.States (939).Action_List.Set_Capacity (40);
- Add_Action (Table.States (939), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (243, 0), 6,
+ Table.States (946).Kernel := To_Vector ((0 => (194, 97, 0,
False)));
+ Table.States (946).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 194, 6)));
+ Table.States (947).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (947), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (244, 0), 6,
null_procedure_declaration_0'Access, null);
- Table.States (939).Kernel := To_Vector ((0 => (243, 96, 0,
False)));
- Table.States (939).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 243, 6)));
- Table.States (940).Action_List.Set_Capacity (40);
- Add_Action (Table.States (940), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (112, 0), 6,
+ Table.States (947).Kernel := To_Vector ((0 => (244, 97, 0,
False)));
+ Table.States (947).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 244, 6)));
+ Table.States (948).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (948), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (113, 0), 6,
abstract_subprogram_declaration_0'Access, null);
- Table.States (940).Kernel := To_Vector ((0 => (112, 96, 0,
False)));
- Table.States (940).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 112, 6)));
- Table.States (941).Action_List.Set_Capacity (40);
- Add_Action (Table.States (941), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (308, 0), 6,
+ Table.States (948).Kernel := To_Vector ((0 => (113, 97, 0,
False)));
+ Table.States (948).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 113, 6)));
+ Table.States (949).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (949), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (309, 0), 6,
subprogram_body_stub_0'Access, null);
- Table.States (941).Kernel := To_Vector ((0 => (308, 96, 0,
False)));
- Table.States (941).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 308, 6)));
- Table.States (942).Action_List.Set_Capacity (40);
- Add_Action (Table.States (942), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (311, 0), 6,
+ Table.States (949).Kernel := To_Vector ((0 => (309, 97, 0,
False)));
+ Table.States (949).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 309, 6)));
+ Table.States (950).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (950), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (312, 0), 6,
subprogram_renaming_declaration_0'Access, null);
- Table.States (942).Kernel := To_Vector ((0 => (311, 96, 0,
False)));
- Table.States (942).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 311, 6)));
- Table.States (943).Action_List.Set_Capacity (24);
- Add_Action (Table.States (943), 4, 1);
- Add_Action (Table.States (943), 5, 2);
- Add_Action (Table.States (943), 13, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (943), 15, 3);
- Add_Action (Table.States (943), 17, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (943), 18, 4);
- Add_Action (Table.States (943), 24, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (943), 26, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (943), 27, 5);
- Add_Action (Table.States (943), 28, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (943), 31, 9);
- Add_Action (Table.States (943), 32, 10);
- Add_Action (Table.States (943), 37, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (943), 41, 13);
- Add_Action (Table.States (943), 48, 16);
- Add_Action (Table.States (943), 52, 20);
- Add_Action (Table.States (943), 57, 21);
- Add_Action (Table.States (943), 58, 22);
- Add_Action (Table.States (943), 61, 24);
- Add_Action (Table.States (943), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (943), 93, 31);
- Add_Action (Table.States (943), 104, 360);
- Add_Action (Table.States (943), 105, 33);
- Add_Action (Table.States (943), 106, 34);
- Table.States (943).Goto_List.Set_Capacity (32);
- Add_Goto (Table.States (943), 113, 36);
- Add_Goto (Table.States (943), 123, 38);
- Add_Goto (Table.States (943), 126, 39);
- Add_Goto (Table.States (943), 128, 41);
- Add_Goto (Table.States (943), 131, 42);
- Add_Goto (Table.States (943), 132, 43);
- Add_Goto (Table.States (943), 133, 44);
- Add_Goto (Table.States (943), 139, 47);
- Add_Goto (Table.States (943), 151, 50);
- Add_Goto (Table.States (943), 152, 51);
- Add_Goto (Table.States (943), 161, 53);
- Add_Goto (Table.States (943), 190, 57);
- Add_Goto (Table.States (943), 196, 59);
- Add_Goto (Table.States (943), 217, 68);
- Add_Goto (Table.States (943), 218, 1079);
- Add_Goto (Table.States (943), 222, 70);
- Add_Goto (Table.States (943), 232, 72);
- Add_Goto (Table.States (943), 239, 73);
- Add_Goto (Table.States (943), 257, 83);
- Add_Goto (Table.States (943), 261, 86);
- Add_Goto (Table.States (943), 272, 92);
- Add_Goto (Table.States (943), 276, 93);
- Add_Goto (Table.States (943), 290, 96);
- Add_Goto (Table.States (943), 293, 97);
- Add_Goto (Table.States (943), 294, 98);
- Add_Goto (Table.States (943), 298, 99);
- Add_Goto (Table.States (943), 299, 361);
- Add_Goto (Table.States (943), 300, 390);
- Add_Goto (Table.States (943), 302, 100);
- Add_Goto (Table.States (943), 303, 101);
- Add_Goto (Table.States (943), 306, 363);
- Add_Goto (Table.States (943), 323, 114);
- Table.States (943).Kernel := To_Vector ((0 => (307, 13, 2,
False)));
- Table.States (943).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 218, 0)));
- Table.States (944).Action_List.Set_Capacity (2);
- Add_Action (Table.States (944), 96, Reduce, (220, 1), 0, null,
null);
- Add_Action (Table.States (944), 104, 149);
- Table.States (944).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (944), 220, 1080);
- Table.States (944).Kernel := To_Vector ((0 => (113, 24, 1,
False)));
- Table.States (944).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 220, 0)));
- Table.States (945).Action_List.Set_Capacity (2);
- Add_Action (Table.States (945), 79, 445);
- Add_Action (Table.States (945), 87, 1081);
- Table.States (945).Kernel := To_Vector (((137, 166, 1, False),
(166, 166, 2, True)));
- Table.States (945).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 87, 1081)));
- Table.States (946).Action_List.Set_Capacity (1);
- Add_Action (Table.States (946), 72, 762);
- Table.States (946).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (946), 137, 1082);
- Table.States (946).Kernel := To_Vector ((0 => (138, 83, 2, True)));
- Table.States (946).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 72, 762)));
- Table.States (946).Minimal_Complete_Actions_Recursive := True;
- Table.States (947).Action_List.Set_Capacity (1);
- Add_Action (Table.States (947), (1 => 77), (273, 0), 5,
quantified_expression_0'Access, null);
- Table.States (947).Kernel := To_Vector ((0 => (273, 192, 0,
False)));
- Table.States (947).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 273, 5)));
- Table.States (948).Action_List.Set_Capacity (13);
- Add_Action (Table.States (948), 3, 121);
- Add_Action (Table.States (948), 39, 122);
- Add_Action (Table.States (948), 40, 123);
- Add_Action (Table.States (948), 41, 124);
- Add_Action (Table.States (948), 52, 125);
- Add_Action (Table.States (948), 76, 126);
- Add_Action (Table.States (948), 77, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (948), 94, 127);
- Add_Action (Table.States (948), 95, 128);
- Add_Action (Table.States (948), 103, 129);
- Add_Action (Table.States (948), 104, 119);
- Add_Action (Table.States (948), 105, 33);
- Add_Action (Table.States (948), 106, 34);
- Table.States (948).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (948), 117, 130);
- Add_Goto (Table.States (948), 128, 41);
- Add_Goto (Table.States (948), 191, 131);
- Add_Goto (Table.States (948), 192, 1083);
- Add_Goto (Table.States (948), 197, 133);
- Add_Goto (Table.States (948), 239, 134);
- Add_Goto (Table.States (948), 258, 135);
- Add_Goto (Table.States (948), 272, 92);
- Add_Goto (Table.States (948), 275, 136);
- Add_Goto (Table.States (948), 282, 137);
- Add_Goto (Table.States (948), 283, 138);
- Add_Goto (Table.States (948), 284, 139);
- Add_Goto (Table.States (948), 285, 140);
- Add_Goto (Table.States (948), 286, 141);
- Add_Goto (Table.States (948), 287, 142);
- Add_Goto (Table.States (948), 293, 97);
- Add_Goto (Table.States (948), 301, 143);
- Add_Goto (Table.States (948), 320, 144);
- Add_Goto (Table.States (948), 321, 145);
- Add_Goto (Table.States (948), 330, 146);
- Table.States (948).Kernel := To_Vector ((0 => (221, 22, 0,
False)));
- Table.States (948).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (949).Action_List.Set_Capacity (13);
- Add_Action (Table.States (949), 3, 121);
- Add_Action (Table.States (949), 39, 122);
- Add_Action (Table.States (949), 40, 123);
- Add_Action (Table.States (949), 41, 124);
- Add_Action (Table.States (949), 52, 125);
- Add_Action (Table.States (949), 68, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (949), 76, 126);
- Add_Action (Table.States (949), 94, 127);
- Add_Action (Table.States (949), 95, 128);
- Add_Action (Table.States (949), 103, 129);
- Add_Action (Table.States (949), 104, 119);
- Add_Action (Table.States (949), 105, 33);
- Add_Action (Table.States (949), 106, 34);
- Table.States (949).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (949), 117, 130);
- Add_Goto (Table.States (949), 128, 41);
- Add_Goto (Table.States (949), 191, 131);
- Add_Goto (Table.States (949), 192, 1084);
- Add_Goto (Table.States (949), 197, 133);
- Add_Goto (Table.States (949), 239, 134);
- Add_Goto (Table.States (949), 258, 135);
- Add_Goto (Table.States (949), 272, 92);
- Add_Goto (Table.States (949), 275, 136);
- Add_Goto (Table.States (949), 282, 137);
- Add_Goto (Table.States (949), 283, 138);
- Add_Goto (Table.States (949), 284, 139);
- Add_Goto (Table.States (949), 285, 140);
- Add_Goto (Table.States (949), 286, 141);
- Add_Goto (Table.States (949), 287, 142);
- Add_Goto (Table.States (949), 293, 97);
- Add_Goto (Table.States (949), 301, 143);
- Add_Goto (Table.States (949), 320, 144);
- Add_Goto (Table.States (949), 321, 145);
- Add_Goto (Table.States (949), 330, 146);
- Table.States (949).Kernel := To_Vector ((0 => (172, 23, 1,
False)));
- Table.States (949).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (950).Action_List.Set_Capacity (3);
- Add_Action (Table.States (950), (22, 23, 77), (173, 1), 1, null,
null);
- Table.States (950).Kernel := To_Vector ((0 => (173, 172, 0,
False)));
- Table.States (950).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 173, 1)));
- Table.States (951).Action_List.Set_Capacity (3);
- Add_Action (Table.States (951), 22, 1085);
- Add_Action (Table.States (951), 23, 949);
- Add_Action (Table.States (951), 77, Reduce, (221, 2), 5,
if_expression_2'Access, null);
- Table.States (951).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (951), 172, 1086);
- Table.States (951).Kernel := To_Vector (((173, 173, 2, True),
(221, 173, 1, False), (221, 173, 0, False)));
- Table.States (951).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 221, 5)));
- Table.States (952).Action_List.Set_Capacity (63);
- Add_Action (Table.States (952), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
- 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
- 88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104,
105, 106), (117, 0), 6, aggregate_0'Access,
- null);
- Table.States (952).Kernel := To_Vector ((0 => (117, 77, 0,
False)));
- Table.States (952).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 117, 6)));
- Table.States (953).Action_List.Set_Capacity (1);
- Add_Action (Table.States (953), 77, 1087);
- Table.States (953).Kernel := To_Vector ((0 => (277, 192, 1,
False)));
- Table.States (953).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 1087)));
- Table.States (954).Action_List.Set_Capacity (2);
- Add_Action (Table.States (954), (24, 72), (140, 0), 4,
case_statement_alternative_0'Access, null);
- Table.States (954).Kernel := To_Vector ((0 => (140, 300, 0,
False)));
- Table.States (954).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 140, 4)));
- Table.States (955).Action_List.Set_Capacity (46);
- Add_Action (Table.States (955), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (139, 0), 7, case_statement_0'Access, null);
- Table.States (955).Kernel := To_Vector ((0 => (139, 96, 0,
False)));
- Table.States (955).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 139, 7)));
- Table.States (956).Action_List.Set_Capacity (10);
- Add_Action (Table.States (956), (10, 21, 37, 42, 74, 77, 82, 83,
87, 96), (314, 0), 4,
- subtype_indication_0'Access, null);
- Table.States (956).Kernel := To_Vector ((0 => (314, 155, 0,
False)));
- Table.States (956).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 314, 4)));
- Table.States (957).Action_List.Set_Capacity (26);
- Add_Action (Table.States (957), 10, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (957), 33, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (957), 38, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (957), 40, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (957), 43, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (957), 55, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (957), 75, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (957), 77, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (957), 78, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (957), 79, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (957), 83, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (957), 85, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (957), 86, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (957), 87, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (957), 88, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (957), 89, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (957), 91, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (957), 92, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (957), 94, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (957), 95, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (957), 97, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (957), 98, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (957), 99, Reduce, (258, 1), 1, null,
null);
- Add_Action (Table.States (957), 104, 119);
- Add_Action (Table.States (957), 105, 33);
+ Table.States (950).Kernel := To_Vector ((0 => (312, 97, 0,
False)));
+ Table.States (950).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 312, 6)));
+ Table.States (951).Action_List.Set_Capacity (25);
+ Add_Action (Table.States (951), 4, 1);
+ Add_Action (Table.States (951), 5, 2);
+ Add_Action (Table.States (951), 13, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (951), 15, 3);
+ Add_Action (Table.States (951), 17, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (951), 18, 4);
+ Add_Action (Table.States (951), 24, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (951), 26, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (951), 27, 5);
+ Add_Action (Table.States (951), 28, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (951), 31, 9);
+ Add_Action (Table.States (951), 32, 10);
+ Add_Action (Table.States (951), 37, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (951), 41, 13);
+ Add_Action (Table.States (951), 48, 16);
+ Add_Action (Table.States (951), 52, 20);
+ Add_Action (Table.States (951), 57, 21);
+ Add_Action (Table.States (951), 58, 22);
+ Add_Action (Table.States (951), 61, 24);
+ Add_Action (Table.States (951), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (951), 79, 31);
+ Add_Action (Table.States (951), 94, 32);
+ Add_Action (Table.States (951), 105, 361);
+ Add_Action (Table.States (951), 106, 34);
+ Add_Action (Table.States (951), 107, 35);
+ Table.States (951).Goto_List.Set_Capacity (32);
+ Add_Goto (Table.States (951), 114, 37);
+ Add_Goto (Table.States (951), 124, 39);
+ Add_Goto (Table.States (951), 127, 40);
+ Add_Goto (Table.States (951), 129, 42);
+ Add_Goto (Table.States (951), 132, 43);
+ Add_Goto (Table.States (951), 133, 44);
+ Add_Goto (Table.States (951), 134, 45);
+ Add_Goto (Table.States (951), 140, 48);
+ Add_Goto (Table.States (951), 152, 51);
+ Add_Goto (Table.States (951), 153, 52);
+ Add_Goto (Table.States (951), 162, 54);
+ Add_Goto (Table.States (951), 191, 58);
+ Add_Goto (Table.States (951), 197, 60);
+ Add_Goto (Table.States (951), 218, 69);
+ Add_Goto (Table.States (951), 219, 1089);
+ Add_Goto (Table.States (951), 223, 71);
+ Add_Goto (Table.States (951), 233, 73);
+ Add_Goto (Table.States (951), 240, 74);
+ Add_Goto (Table.States (951), 258, 84);
+ Add_Goto (Table.States (951), 262, 87);
+ Add_Goto (Table.States (951), 273, 93);
+ Add_Goto (Table.States (951), 277, 94);
+ Add_Goto (Table.States (951), 291, 97);
+ Add_Goto (Table.States (951), 294, 98);
+ Add_Goto (Table.States (951), 295, 99);
+ Add_Goto (Table.States (951), 299, 100);
+ Add_Goto (Table.States (951), 300, 362);
+ Add_Goto (Table.States (951), 301, 391);
+ Add_Goto (Table.States (951), 303, 101);
+ Add_Goto (Table.States (951), 304, 102);
+ Add_Goto (Table.States (951), 307, 364);
+ Add_Goto (Table.States (951), 324, 115);
+ Table.States (951).Kernel := To_Vector ((0 => (308, 13, 2,
False)));
+ Table.States (951).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 219, 0)));
+ Table.States (952).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (952), 97, Reduce, (221, 1), 0, null,
null);
+ Add_Action (Table.States (952), 105, 150);
+ Table.States (952).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (952), 221, 1090);
+ Table.States (952).Kernel := To_Vector ((0 => (114, 24, 1,
False)));
+ Table.States (952).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 221, 0)));
+ Table.States (953).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (953), 80, 447);
+ Add_Action (Table.States (953), 88, 1091);
+ Table.States (953).Kernel := To_Vector (((138, 167, 1, False),
(167, 167, 2, True)));
+ Table.States (953).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 88, 1091)));
+ Table.States (954).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (954), 72, 768);
+ Table.States (954).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (954), 138, 1092);
+ Table.States (954).Kernel := To_Vector ((0 => (139, 84, 2, True)));
+ Table.States (954).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 72, 768)));
+ Table.States (954).Minimal_Complete_Actions_Recursive := True;
+ Table.States (955).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (955), 3, 122);
+ Add_Action (Table.States (955), 39, 123);
+ Add_Action (Table.States (955), 40, 124);
+ Add_Action (Table.States (955), 41, 125);
+ Add_Action (Table.States (955), 52, 126);
+ Add_Action (Table.States (955), 76, 127);
+ Add_Action (Table.States (955), 79, 31);
+ Add_Action (Table.States (955), 95, 128);
+ Add_Action (Table.States (955), 96, 129);
+ Add_Action (Table.States (955), 104, 130);
+ Add_Action (Table.States (955), 105, 120);
+ Add_Action (Table.States (955), 106, 34);
+ Add_Action (Table.States (955), 107, 35);
+ Table.States (955).Goto_List.Set_Capacity (19);
+ Add_Goto (Table.States (955), 118, 131);
+ Add_Goto (Table.States (955), 129, 42);
+ Add_Goto (Table.States (955), 192, 1093);
+ Add_Goto (Table.States (955), 198, 134);
+ Add_Goto (Table.States (955), 240, 135);
+ Add_Goto (Table.States (955), 259, 136);
+ Add_Goto (Table.States (955), 273, 93);
+ Add_Goto (Table.States (955), 276, 137);
+ Add_Goto (Table.States (955), 283, 138);
+ Add_Goto (Table.States (955), 284, 139);
+ Add_Goto (Table.States (955), 285, 140);
+ Add_Goto (Table.States (955), 286, 141);
+ Add_Goto (Table.States (955), 287, 142);
+ Add_Goto (Table.States (955), 288, 143);
+ Add_Goto (Table.States (955), 294, 98);
+ Add_Goto (Table.States (955), 302, 144);
+ Add_Goto (Table.States (955), 321, 145);
+ Add_Goto (Table.States (955), 322, 146);
+ Add_Goto (Table.States (955), 331, 147);
+ Table.States (955).Kernel := To_Vector ((0 => (125, 88, 1,
False)));
+ Table.States (955).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
+ Table.States (956).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (956), (1 => 77), (274, 0), 5,
quantified_expression_0'Access, null);
+ Table.States (956).Kernel := To_Vector ((0 => (274, 193, 0,
False)));
+ Table.States (956).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 274, 5)));
+ Table.States (957).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (957), 3, 122);
+ Add_Action (Table.States (957), 39, 123);
+ Add_Action (Table.States (957), 40, 124);
+ Add_Action (Table.States (957), 41, 125);
+ Add_Action (Table.States (957), 52, 126);
+ Add_Action (Table.States (957), 76, 127);
+ Add_Action (Table.States (957), 77, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (957), 79, 31);
+ Add_Action (Table.States (957), 95, 128);
+ Add_Action (Table.States (957), 96, 129);
+ Add_Action (Table.States (957), 104, 130);
+ Add_Action (Table.States (957), 105, 120);
Add_Action (Table.States (957), 106, 34);
- Table.States (957).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (957), 128, 41);
- Add_Goto (Table.States (957), 239, 1088);
- Add_Goto (Table.States (957), 272, 92);
- Add_Goto (Table.States (957), 293, 97);
- Table.States (957).Kernel := To_Vector (((165, 41, 1, False),
(258, 41, 0, False), (314, 41, 5, False),
- (314, 41, 1, False)));
- Table.States (957).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 258, 1)));
- Table.States (958).Action_List.Set_Capacity (10);
- Add_Action (Table.States (958), (10, 21, 37, 42, 74, 77, 82, 83,
87, 96), (224, 0), 3,
- index_constraint_0'Access, null);
- Table.States (958).Kernel := To_Vector ((0 => (224, 77, 0,
False)));
- Table.States (958).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 224, 3)));
- Table.States (959).Action_List.Set_Capacity (11);
- Add_Action (Table.States (959), 3, 121);
- Add_Action (Table.States (959), 39, 122);
- Add_Action (Table.States (959), 40, 474);
- Add_Action (Table.States (959), 41, 124);
- Add_Action (Table.States (959), 76, 126);
- Add_Action (Table.States (959), 94, 127);
- Add_Action (Table.States (959), 95, 128);
- Add_Action (Table.States (959), 103, 129);
- Add_Action (Table.States (959), 104, 119);
- Add_Action (Table.States (959), 105, 33);
- Add_Action (Table.States (959), 106, 34);
- Table.States (959).Goto_List.Set_Capacity (14);
- Add_Goto (Table.States (959), 117, 130);
- Add_Goto (Table.States (959), 128, 41);
- Add_Goto (Table.States (959), 167, 1089);
- Add_Goto (Table.States (959), 197, 133);
- Add_Goto (Table.States (959), 239, 477);
- Add_Goto (Table.States (959), 258, 135);
- Add_Goto (Table.States (959), 272, 92);
- Add_Goto (Table.States (959), 277, 478);
- Add_Goto (Table.States (959), 293, 97);
- Add_Goto (Table.States (959), 301, 479);
- Add_Goto (Table.States (959), 314, 480);
- Add_Goto (Table.States (959), 320, 144);
- Add_Goto (Table.States (959), 321, 145);
- Add_Goto (Table.States (959), 330, 146);
- Table.States (959).Kernel := To_Vector ((0 => (168, 83, 1, True)));
- Table.States (959).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (959).Minimal_Complete_Actions_Recursive := True;
- end Subr_16;
- procedure Subr_17
- is begin
- Table.States (960).Action_List.Set_Capacity (6);
- Add_Action (Table.States (960), 37, Reduce, (230, 0), 6, null,
null);
- Add_Action (Table.States (960), 76, 235);
- Add_Action (Table.States (960), 84, 237);
- Add_Action (Table.States (960), 87, Reduce, (230, 0), 6, null,
null);
- Add_Action (Table.States (960), 101, 239);
- Add_Action (Table.States (960), 102, 240);
- Table.States (960).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (960), 115, 241);
- Add_Goto (Table.States (960), 322, 242);
- Table.States (960).Kernel := To_Vector (((128, 239, 2, True),
(230, 239, 0, False), (239, 239, 5, True),
- (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (960).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 230, 6)));
- Table.States (961).Action_List.Set_Capacity (1);
- Add_Action (Table.States (961), 96, 1090);
- Table.States (961).Kernel := To_Vector ((0 => (235, 192, 1,
False)));
- Table.States (961).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1090)));
- Table.States (962).Action_List.Set_Capacity (11);
- Add_Action (Table.States (962), 3, 121);
- Add_Action (Table.States (962), 39, 122);
- Add_Action (Table.States (962), 40, 123);
- Add_Action (Table.States (962), 41, 124);
- Add_Action (Table.States (962), 76, 126);
- Add_Action (Table.States (962), 94, 127);
- Add_Action (Table.States (962), 95, 128);
- Add_Action (Table.States (962), 103, 129);
- Add_Action (Table.States (962), 104, 119);
- Add_Action (Table.States (962), 105, 33);
- Add_Action (Table.States (962), 106, 34);
- Table.States (962).Goto_List.Set_Capacity (11);
- Add_Goto (Table.States (962), 117, 130);
- Add_Goto (Table.States (962), 128, 41);
- Add_Goto (Table.States (962), 197, 133);
- Add_Goto (Table.States (962), 239, 134);
- Add_Goto (Table.States (962), 258, 135);
- Add_Goto (Table.States (962), 272, 92);
- Add_Goto (Table.States (962), 293, 97);
- Add_Goto (Table.States (962), 301, 1091);
- Add_Goto (Table.States (962), 320, 144);
- Add_Goto (Table.States (962), 321, 145);
- Add_Goto (Table.States (962), 330, 146);
- Table.States (962).Kernel := To_Vector ((0 => (144, 12, 6,
False)));
- Table.States (962).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
+ Add_Action (Table.States (957), 107, 35);
+ Table.States (957).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (957), 118, 131);
+ Add_Goto (Table.States (957), 129, 42);
+ Add_Goto (Table.States (957), 192, 132);
+ Add_Goto (Table.States (957), 193, 1094);
+ Add_Goto (Table.States (957), 198, 134);
+ Add_Goto (Table.States (957), 240, 135);
+ Add_Goto (Table.States (957), 259, 136);
+ Add_Goto (Table.States (957), 273, 93);
+ Add_Goto (Table.States (957), 276, 137);
+ Add_Goto (Table.States (957), 283, 138);
+ Add_Goto (Table.States (957), 284, 139);
+ Add_Goto (Table.States (957), 285, 140);
+ Add_Goto (Table.States (957), 286, 141);
+ Add_Goto (Table.States (957), 287, 142);
+ Add_Goto (Table.States (957), 288, 143);
+ Add_Goto (Table.States (957), 294, 98);
+ Add_Goto (Table.States (957), 302, 144);
+ Add_Goto (Table.States (957), 321, 145);
+ Add_Goto (Table.States (957), 322, 146);
+ Add_Goto (Table.States (957), 331, 147);
+ Table.States (957).Kernel := To_Vector ((0 => (222, 22, 0,
False)));
+ Table.States (957).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (958).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (958), 3, 122);
+ Add_Action (Table.States (958), 39, 123);
+ Add_Action (Table.States (958), 40, 124);
+ Add_Action (Table.States (958), 41, 125);
+ Add_Action (Table.States (958), 52, 126);
+ Add_Action (Table.States (958), 68, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (958), 76, 127);
+ Add_Action (Table.States (958), 79, 31);
+ Add_Action (Table.States (958), 95, 128);
+ Add_Action (Table.States (958), 96, 129);
+ Add_Action (Table.States (958), 104, 130);
+ Add_Action (Table.States (958), 105, 120);
+ Add_Action (Table.States (958), 106, 34);
+ Add_Action (Table.States (958), 107, 35);
+ Table.States (958).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (958), 118, 131);
+ Add_Goto (Table.States (958), 129, 42);
+ Add_Goto (Table.States (958), 192, 132);
+ Add_Goto (Table.States (958), 193, 1095);
+ Add_Goto (Table.States (958), 198, 134);
+ Add_Goto (Table.States (958), 240, 135);
+ Add_Goto (Table.States (958), 259, 136);
+ Add_Goto (Table.States (958), 273, 93);
+ Add_Goto (Table.States (958), 276, 137);
+ Add_Goto (Table.States (958), 283, 138);
+ Add_Goto (Table.States (958), 284, 139);
+ Add_Goto (Table.States (958), 285, 140);
+ Add_Goto (Table.States (958), 286, 141);
+ Add_Goto (Table.States (958), 287, 142);
+ Add_Goto (Table.States (958), 288, 143);
+ Add_Goto (Table.States (958), 294, 98);
+ Add_Goto (Table.States (958), 302, 144);
+ Add_Goto (Table.States (958), 321, 145);
+ Add_Goto (Table.States (958), 322, 146);
+ Add_Goto (Table.States (958), 331, 147);
+ Table.States (958).Kernel := To_Vector ((0 => (173, 23, 1,
False)));
+ Table.States (958).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (959).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (959), (22, 23, 77), (174, 1), 1, null,
null);
+ Table.States (959).Kernel := To_Vector ((0 => (174, 173, 0,
False)));
+ Table.States (959).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 174, 1)));
+ Table.States (960).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (960), 22, 1096);
+ Add_Action (Table.States (960), 23, 958);
+ Add_Action (Table.States (960), 77, Reduce, (222, 2), 5,
if_expression_2'Access, null);
+ Table.States (960).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (960), 173, 1097);
+ Table.States (960).Kernel := To_Vector (((174, 174, 2, True),
(222, 174, 1, False), (222, 174, 0, False)));
+ Table.States (960).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 222, 5)));
+ Table.States (961).Action_List.Set_Capacity (64);
+ Add_Action (Table.States (961), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+ 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
105, 106, 107), (118, 3), 6,
+ aggregate_3'Access, null);
+ Table.States (961).Kernel := To_Vector ((0 => (118, 77, 0,
False)));
+ Table.States (961).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 118, 6)));
+ Table.States (962).Action_List.Set_Capacity (64);
+ Add_Action (Table.States (962), (4, 5, 10, 13, 15, 17, 18, 20, 21,
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
+ 40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74,
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+ 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
105, 106, 107), (118, 0), 6,
+ aggregate_0'Access, null);
+ Table.States (962).Kernel := To_Vector ((0 => (118, 77, 0,
False)));
+ Table.States (962).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 118, 6)));
Table.States (963).Action_List.Set_Capacity (1);
- Add_Action (Table.States (963), 54, 1092);
- Table.States (963).Kernel := To_Vector ((0 => (281, 24, 2,
False)));
- Table.States (963).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 54, 1092)));
+ Add_Action (Table.States (963), 77, 1098);
+ Table.States (963).Kernel := To_Vector ((0 => (278, 193, 1,
False)));
+ Table.States (963).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 1098)));
Table.States (964).Action_List.Set_Capacity (2);
- Add_Action (Table.States (964), (24, 104), (145, 0), 2, null,
null);
- Table.States (964).Kernel := To_Vector ((0 => (145, 144, 0,
True)));
- Table.States (964).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 145, 2)));
- Table.States (964).Minimal_Complete_Actions_Recursive := True;
- Table.States (965).Action_List.Set_Capacity (3);
- Add_Action (Table.States (965), 77, Reduce, (254, 3), 4,
parameter_specification_3'Access, null);
- Add_Action (Table.States (965), 82, 1093);
- Add_Action (Table.States (965), 96, Reduce, (254, 3), 4,
parameter_specification_3'Access, null);
- Table.States (965).Kernel := To_Vector (((254, 114, 1, False),
(254, 114, 0, False)));
- Table.States (965).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 254, 4)));
- Table.States (966).Action_List.Set_Capacity (4);
- Add_Action (Table.States (966), 40, 386);
- Add_Action (Table.States (966), 104, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (966), 105, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (966), 106, Reduce, (241, 1), 0, null,
null);
- Table.States (966).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (966), 241, 1094);
- Table.States (966).Kernel := To_Vector (((254, 236, 2, False),
(254, 236, 1, False)));
- Table.States (966).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 241, 0)));
- Table.States (967).Action_List.Set_Capacity (40);
- Add_Action (Table.States (967), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (215, 2), 7,
+ Add_Action (Table.States (964), (24, 72), (141, 0), 4,
case_statement_alternative_0'Access, null);
+ Table.States (964).Kernel := To_Vector ((0 => (141, 301, 0,
False)));
+ Table.States (964).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 141, 4)));
+ Table.States (965).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (965), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (140, 0), 7, case_statement_0'Access, null);
+ Table.States (965).Kernel := To_Vector ((0 => (140, 97, 0,
False)));
+ Table.States (965).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 140, 7)));
+ Table.States (966).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (966), (10, 21, 37, 42, 74, 77, 83, 84,
88, 97), (315, 0), 4,
+ subtype_indication_0'Access, null);
+ Table.States (966).Kernel := To_Vector ((0 => (315, 156, 0,
False)));
+ Table.States (966).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 315, 4)));
+ Table.States (967).Action_List.Set_Capacity (27);
+ Add_Action (Table.States (967), 10, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (967), 33, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (967), 38, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (967), 40, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (967), 43, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (967), 55, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (967), 75, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (967), 77, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (967), 78, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (967), 79, 31);
+ Add_Action (Table.States (967), 80, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (967), 84, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (967), 86, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (967), 87, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (967), 88, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (967), 89, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (967), 90, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (967), 92, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (967), 93, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (967), 95, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (967), 96, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (967), 98, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (967), 99, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (967), 100, Reduce, (259, 1), 1, null,
null);
+ Add_Action (Table.States (967), 105, 120);
+ Add_Action (Table.States (967), 106, 34);
+ Add_Action (Table.States (967), 107, 35);
+ Table.States (967).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (967), 129, 42);
+ Add_Goto (Table.States (967), 240, 1099);
+ Add_Goto (Table.States (967), 273, 93);
+ Add_Goto (Table.States (967), 294, 98);
+ Table.States (967).Kernel := To_Vector (((166, 41, 1, False),
(259, 41, 0, False), (315, 41, 5, False),
+ (315, 41, 1, False)));
+ Table.States (967).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 259, 1)));
+ Table.States (968).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (968), (10, 21, 37, 42, 74, 77, 83, 84,
88, 97), (225, 0), 3,
+ index_constraint_0'Access, null);
+ Table.States (968).Kernel := To_Vector ((0 => (225, 77, 0,
False)));
+ Table.States (968).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 225, 3)));
+ Table.States (969).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (969), 3, 122);
+ Add_Action (Table.States (969), 39, 123);
+ Add_Action (Table.States (969), 40, 477);
+ Add_Action (Table.States (969), 41, 125);
+ Add_Action (Table.States (969), 76, 127);
+ Add_Action (Table.States (969), 79, 31);
+ Add_Action (Table.States (969), 95, 128);
+ Add_Action (Table.States (969), 96, 129);
+ Add_Action (Table.States (969), 104, 130);
+ Add_Action (Table.States (969), 105, 120);
+ Add_Action (Table.States (969), 106, 34);
+ Add_Action (Table.States (969), 107, 35);
+ Table.States (969).Goto_List.Set_Capacity (14);
+ Add_Goto (Table.States (969), 118, 131);
+ Add_Goto (Table.States (969), 129, 42);
+ Add_Goto (Table.States (969), 168, 1100);
+ Add_Goto (Table.States (969), 198, 134);
+ Add_Goto (Table.States (969), 240, 480);
+ Add_Goto (Table.States (969), 259, 136);
+ Add_Goto (Table.States (969), 273, 93);
+ Add_Goto (Table.States (969), 278, 481);
+ Add_Goto (Table.States (969), 294, 98);
+ Add_Goto (Table.States (969), 302, 482);
+ Add_Goto (Table.States (969), 315, 483);
+ Add_Goto (Table.States (969), 321, 145);
+ Add_Goto (Table.States (969), 322, 146);
+ Add_Goto (Table.States (969), 331, 147);
+ Table.States (969).Kernel := To_Vector ((0 => (169, 84, 1, True)));
+ Table.States (969).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (969).Minimal_Complete_Actions_Recursive := True;
+ Table.States (970).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (970), 37, Reduce, (231, 0), 6, null,
null);
+ Add_Action (Table.States (970), 76, 236);
+ Add_Action (Table.States (970), 85, 238);
+ Add_Action (Table.States (970), 88, Reduce, (231, 0), 6, null,
null);
+ Add_Action (Table.States (970), 102, 240);
+ Add_Action (Table.States (970), 103, 241);
+ Table.States (970).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (970), 116, 242);
+ Add_Goto (Table.States (970), 323, 243);
+ Table.States (970).Kernel := To_Vector (((129, 240, 2, True),
(231, 240, 0, False), (240, 240, 5, True),
+ (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (970).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 231, 6)));
+ Table.States (971).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (971), 97, 1101);
+ Table.States (971).Kernel := To_Vector ((0 => (236, 193, 1,
False)));
+ Table.States (971).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1101)));
+ Table.States (972).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (972), 3, 122);
+ Add_Action (Table.States (972), 39, 123);
+ Add_Action (Table.States (972), 40, 124);
+ Add_Action (Table.States (972), 41, 125);
+ Add_Action (Table.States (972), 76, 127);
+ Add_Action (Table.States (972), 79, 31);
+ Add_Action (Table.States (972), 95, 128);
+ Add_Action (Table.States (972), 96, 129);
+ Add_Action (Table.States (972), 104, 130);
+ Add_Action (Table.States (972), 105, 120);
+ Add_Action (Table.States (972), 106, 34);
+ Add_Action (Table.States (972), 107, 35);
+ Table.States (972).Goto_List.Set_Capacity (11);
+ Add_Goto (Table.States (972), 118, 131);
+ Add_Goto (Table.States (972), 129, 42);
+ Add_Goto (Table.States (972), 198, 134);
+ Add_Goto (Table.States (972), 240, 135);
+ Add_Goto (Table.States (972), 259, 136);
+ Add_Goto (Table.States (972), 273, 93);
+ Add_Goto (Table.States (972), 294, 98);
+ Add_Goto (Table.States (972), 302, 1102);
+ Add_Goto (Table.States (972), 321, 145);
+ Add_Goto (Table.States (972), 322, 146);
+ Add_Goto (Table.States (972), 331, 147);
+ Table.States (972).Kernel := To_Vector ((0 => (145, 12, 6,
False)));
+ Table.States (972).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
+ Table.States (973).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (973), 54, 1103);
+ Table.States (973).Kernel := To_Vector ((0 => (282, 24, 2,
False)));
+ Table.States (973).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 54, 1103)));
+ Table.States (974).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (974), (24, 105), (146, 0), 2, null,
null);
+ Table.States (974).Kernel := To_Vector ((0 => (146, 145, 0,
True)));
+ Table.States (974).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 146, 2)));
+ Table.States (974).Minimal_Complete_Actions_Recursive := True;
+ Table.States (975).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (975), 77, Reduce, (255, 3), 4,
parameter_specification_3'Access, null);
+ Add_Action (Table.States (975), 83, 1104);
+ Add_Action (Table.States (975), 97, Reduce, (255, 3), 4,
parameter_specification_3'Access, null);
+ Table.States (975).Kernel := To_Vector (((255, 115, 1, False),
(255, 115, 0, False)));
+ Table.States (975).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 255, 4)));
+ Table.States (976).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (976), 40, 387);
+ Add_Action (Table.States (976), 79, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (976), 105, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (976), 106, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (976), 107, Reduce, (242, 1), 0, null,
null);
+ Table.States (976).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (976), 242, 1105);
+ Table.States (976).Kernel := To_Vector (((255, 237, 2, False),
(255, 237, 1, False)));
+ Table.States (976).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 242, 0)));
+ Table.States (977).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (977), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (216, 2), 7,
generic_renaming_declaration_2'Access, null);
- Table.States (967).Kernel := To_Vector ((0 => (215, 96, 0,
False)));
- Table.States (967).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 215, 7)));
- Table.States (968).Action_List.Set_Capacity (40);
- Add_Action (Table.States (968), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (215, 0), 7,
+ Table.States (977).Kernel := To_Vector ((0 => (216, 97, 0,
False)));
+ Table.States (977).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 216, 7)));
+ Table.States (978).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (978), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (216, 0), 7,
generic_renaming_declaration_0'Access, null);
- Table.States (968).Kernel := To_Vector ((0 => (215, 96, 0,
False)));
- Table.States (968).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 215, 7)));
- Table.States (969).Action_List.Set_Capacity (40);
- Add_Action (Table.States (969), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (215, 1), 7,
+ Table.States (978).Kernel := To_Vector ((0 => (216, 97, 0,
False)));
+ Table.States (978).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 216, 7)));
+ Table.States (979).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (979), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (216, 1), 7,
generic_renaming_declaration_1'Access, null);
- Table.States (969).Kernel := To_Vector ((0 => (215, 96, 0,
False)));
- Table.States (969).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 215, 7)));
- Table.States (970).Action_List.Set_Capacity (1);
- Add_Action (Table.States (970), (1 => 39), (109, 0), 2, null,
null);
- Table.States (970).Kernel := To_Vector ((0 => (109, 36, 0,
False)));
- Table.States (970).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 109, 2)));
- Table.States (971).Action_List.Set_Capacity (3);
- Add_Action (Table.States (971), 20, 1095);
- Add_Action (Table.States (971), 74, Reduce, (202, 7), 2, null,
null);
- Add_Action (Table.States (971), 96, Reduce, (202, 7), 2, null,
null);
- Table.States (971).Kernel := To_Vector (((202, 80, 2, False),
(202, 80, 0, False)));
- Table.States (971).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 202, 2)));
- Table.States (972).Action_List.Set_Capacity (2);
- Add_Action (Table.States (972), (74, 96), (202, 5), 2, null, null);
- Table.States (972).Kernel := To_Vector ((0 => (202, 80, 0,
False)));
- Table.States (972).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 202, 2)));
- Table.States (973).Action_List.Set_Capacity (2);
- Add_Action (Table.States (973), (74, 96), (202, 4), 2, null, null);
- Table.States (973).Kernel := To_Vector ((0 => (202, 80, 0,
False)));
- Table.States (973).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 202, 2)));
- Table.States (974).Action_List.Set_Capacity (2);
- Add_Action (Table.States (974), (74, 96), (202, 3), 2, null, null);
- Table.States (974).Kernel := To_Vector ((0 => (202, 80, 0,
False)));
- Table.States (974).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 202, 2)));
- Table.States (975).Action_List.Set_Capacity (1);
- Add_Action (Table.States (975), 96, 1096);
- Table.States (975).Kernel := To_Vector ((0 => (201, 122, 1,
False)));
- Table.States (975).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1096)));
- Table.States (976).Action_List.Set_Capacity (1);
- Add_Action (Table.States (976), 77, 1097);
- Table.States (976).Kernel := To_Vector ((0 => (202, 80, 1,
False)));
- Table.States (976).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 1097)));
- Table.States (977).Action_List.Set_Capacity (3);
- Add_Action (Table.States (977), 104, 119);
- Add_Action (Table.States (977), 105, 33);
- Add_Action (Table.States (977), 106, 34);
- Table.States (977).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (977), 128, 41);
- Add_Goto (Table.States (977), 239, 1098);
- Add_Goto (Table.States (977), 272, 92);
- Add_Goto (Table.States (977), 293, 97);
- Table.States (977).Kernel := To_Vector (((203, 39, 3, False),
(203, 39, 1, False)));
- Table.States (977).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (978).Action_List.Set_Capacity (2);
- Add_Action (Table.States (978), (74, 96), (202, 0), 2, null, null);
- Table.States (978).Kernel := To_Vector ((0 => (202, 49, 0,
False)));
- Table.States (978).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 202, 2)));
- Table.States (979).Action_List.Set_Capacity (1);
- Add_Action (Table.States (979), 96, 1099);
- Table.States (979).Kernel := To_Vector ((0 => (201, 122, 1,
False)));
- Table.States (979).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1099)));
- Table.States (980).Action_List.Set_Capacity (6);
- Add_Action (Table.States (980), 74, Reduce, (205, 1), 0, null,
null);
- Add_Action (Table.States (980), 76, 1100);
- Add_Action (Table.States (980), 84, 237);
- Add_Action (Table.States (980), 96, Reduce, (205, 1), 0, null,
null);
- Add_Action (Table.States (980), 101, 239);
- Add_Action (Table.States (980), 102, 240);
- Table.States (980).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (980), 115, 241);
- Add_Goto (Table.States (980), 205, 1101);
- Add_Goto (Table.States (980), 322, 242);
- Table.States (980).Kernel := To_Vector (((128, 239, 2, True),
(204, 239, 1, False), (239, 239, 5, True),
- (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (980).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 205, 0)));
- Table.States (981).Action_List.Set_Capacity (8);
- Add_Action (Table.States (981), (29, 47, 48, 50, 69, 71, 74, 104),
(200, 2), 6,
+ Table.States (979).Kernel := To_Vector ((0 => (216, 97, 0,
False)));
+ Table.States (979).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 216, 7)));
+ Table.States (980).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (980), (1 => 39), (110, 0), 2, null,
null);
+ Table.States (980).Kernel := To_Vector ((0 => (110, 36, 0,
False)));
+ Table.States (980).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 110, 2)));
+ Table.States (981).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (981), 20, 1106);
+ Add_Action (Table.States (981), 74, Reduce, (203, 7), 2, null,
null);
+ Add_Action (Table.States (981), 97, Reduce, (203, 7), 2, null,
null);
+ Table.States (981).Kernel := To_Vector (((203, 81, 2, False),
(203, 81, 0, False)));
+ Table.States (981).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 203, 2)));
+ Table.States (982).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (982), (74, 97), (203, 5), 2, null, null);
+ Table.States (982).Kernel := To_Vector ((0 => (203, 81, 0,
False)));
+ Table.States (982).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 203, 2)));
+ Table.States (983).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (983), (74, 97), (203, 4), 2, null, null);
+ Table.States (983).Kernel := To_Vector ((0 => (203, 81, 0,
False)));
+ Table.States (983).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 203, 2)));
+ Table.States (984).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (984), (74, 97), (203, 3), 2, null, null);
+ Table.States (984).Kernel := To_Vector ((0 => (203, 81, 0,
False)));
+ Table.States (984).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 203, 2)));
+ Table.States (985).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (985), 97, 1107);
+ Table.States (985).Kernel := To_Vector ((0 => (202, 123, 1,
False)));
+ Table.States (985).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1107)));
+ Table.States (986).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (986), 77, 1108);
+ Table.States (986).Kernel := To_Vector ((0 => (203, 81, 1,
False)));
+ Table.States (986).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 1108)));
+ Table.States (987).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (987), 79, 31);
+ Add_Action (Table.States (987), 105, 120);
+ Add_Action (Table.States (987), 106, 34);
+ Add_Action (Table.States (987), 107, 35);
+ Table.States (987).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (987), 129, 42);
+ Add_Goto (Table.States (987), 240, 1109);
+ Add_Goto (Table.States (987), 273, 93);
+ Add_Goto (Table.States (987), 294, 98);
+ Table.States (987).Kernel := To_Vector (((204, 39, 3, False),
(204, 39, 1, False)));
+ Table.States (987).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (988).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (988), (74, 97), (203, 0), 2, null, null);
+ Table.States (988).Kernel := To_Vector ((0 => (203, 49, 0,
False)));
+ Table.States (988).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 203, 2)));
+ Table.States (989).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (989), 97, 1110);
+ Table.States (989).Kernel := To_Vector ((0 => (202, 123, 1,
False)));
+ Table.States (989).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1110)));
+ Table.States (990).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (990), 74, Reduce, (206, 1), 0, null,
null);
+ Add_Action (Table.States (990), 76, 1111);
+ Add_Action (Table.States (990), 85, 238);
+ Add_Action (Table.States (990), 97, Reduce, (206, 1), 0, null,
null);
+ Add_Action (Table.States (990), 102, 240);
+ Add_Action (Table.States (990), 103, 241);
+ Table.States (990).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (990), 116, 242);
+ Add_Goto (Table.States (990), 206, 1112);
+ Add_Goto (Table.States (990), 323, 243);
+ Table.States (990).Kernel := To_Vector (((129, 240, 2, True),
(205, 240, 1, False), (240, 240, 5, True),
+ (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (990).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 206, 0)));
+ Table.States (991).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (991), (29, 47, 48, 50, 69, 71, 74, 105),
(201, 2), 6,
formal_subprogram_declaration_2'Access, null);
- Table.States (981).Kernel := To_Vector ((0 => (200, 96, 0,
False)));
- Table.States (981).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 200, 6)));
- Table.States (982).Action_List.Set_Capacity (1);
- Add_Action (Table.States (982), 96, 1102);
- Table.States (982).Kernel := To_Vector ((0 => (200, 122, 1,
False)));
- Table.States (982).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1102)));
- Table.States (983).Action_List.Set_Capacity (8);
- Add_Action (Table.States (983), (29, 47, 48, 50, 69, 71, 74, 104),
(200, 1), 6,
+ Table.States (991).Kernel := To_Vector ((0 => (201, 97, 0,
False)));
+ Table.States (991).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 201, 6)));
+ Table.States (992).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (992), 97, 1113);
+ Table.States (992).Kernel := To_Vector ((0 => (201, 123, 1,
False)));
+ Table.States (992).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1113)));
+ Table.States (993).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (993), (29, 47, 48, 50, 69, 71, 74, 105),
(201, 1), 6,
formal_subprogram_declaration_1'Access, null);
- Table.States (983).Kernel := To_Vector ((0 => (200, 96, 0,
False)));
- Table.States (983).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 200, 6)));
- Table.States (984).Action_List.Set_Capacity (2);
- Add_Action (Table.States (984), 74, 337);
- Add_Action (Table.States (984), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (984).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (984), 122, 1103);
- Table.States (984).Kernel := To_Vector ((0 => (198, 192, 1,
False)));
- Table.States (984).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (985).Action_List.Set_Capacity (8);
- Add_Action (Table.States (985), (29, 47, 48, 50, 69, 71, 74, 104),
(198, 3), 6,
+ Table.States (993).Kernel := To_Vector ((0 => (201, 97, 0,
False)));
+ Table.States (993).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 201, 6)));
+ Table.States (994).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (994), 74, 338);
+ Add_Action (Table.States (994), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (994).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (994), 123, 1114);
+ Table.States (994).Kernel := To_Vector ((0 => (199, 193, 1,
False)));
+ Table.States (994).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (995).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (995), (29, 47, 48, 50, 69, 71, 74, 105),
(199, 3), 6,
formal_object_declaration_3'Access, null);
- Table.States (985).Kernel := To_Vector ((0 => (198, 96, 0,
False)));
- Table.States (985).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 198, 6)));
- Table.States (986).Action_List.Set_Capacity (14);
- Add_Action (Table.States (986), 3, 121);
- Add_Action (Table.States (986), 39, 122);
- Add_Action (Table.States (986), 40, 123);
- Add_Action (Table.States (986), 41, 124);
- Add_Action (Table.States (986), 52, 125);
- Add_Action (Table.States (986), 74, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (986), 76, 126);
- Add_Action (Table.States (986), 94, 127);
- Add_Action (Table.States (986), 95, 128);
- Add_Action (Table.States (986), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (986), 103, 129);
- Add_Action (Table.States (986), 104, 119);
- Add_Action (Table.States (986), 105, 33);
- Add_Action (Table.States (986), 106, 34);
- Table.States (986).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (986), 117, 130);
- Add_Goto (Table.States (986), 128, 41);
- Add_Goto (Table.States (986), 191, 131);
- Add_Goto (Table.States (986), 192, 1104);
- Add_Goto (Table.States (986), 197, 133);
- Add_Goto (Table.States (986), 239, 134);
- Add_Goto (Table.States (986), 258, 135);
- Add_Goto (Table.States (986), 272, 92);
- Add_Goto (Table.States (986), 275, 136);
- Add_Goto (Table.States (986), 282, 137);
- Add_Goto (Table.States (986), 283, 138);
- Add_Goto (Table.States (986), 284, 139);
- Add_Goto (Table.States (986), 285, 140);
- Add_Goto (Table.States (986), 286, 141);
- Add_Goto (Table.States (986), 287, 142);
- Add_Goto (Table.States (986), 293, 97);
- Add_Goto (Table.States (986), 301, 143);
- Add_Goto (Table.States (986), 320, 144);
- Add_Goto (Table.States (986), 321, 145);
- Add_Goto (Table.States (986), 330, 146);
- Table.States (986).Kernel := To_Vector ((0 => (198, 82, 1,
False)));
- Table.States (986).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (987).Action_List.Set_Capacity (1);
- Add_Action (Table.States (987), 96, 1105);
- Table.States (987).Kernel := To_Vector ((0 => (198, 122, 1,
False)));
- Table.States (987).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1105)));
- Table.States (988).Action_List.Set_Capacity (1);
- Add_Action (Table.States (988), 32, 1106);
- Table.States (988).Kernel := To_Vector ((0 => (222, 24, 2,
False)));
- Table.States (988).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 32, 1106)));
- Table.States (989).Action_List.Set_Capacity (25);
- Add_Action (Table.States (989), 4, 1);
- Add_Action (Table.States (989), 5, 2);
- Add_Action (Table.States (989), 13, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (989), 15, 3);
- Add_Action (Table.States (989), 17, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (989), 18, 4);
- Add_Action (Table.States (989), 22, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (989), 23, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (989), 24, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (989), 27, 5);
- Add_Action (Table.States (989), 28, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (989), 31, 9);
- Add_Action (Table.States (989), 32, 10);
- Add_Action (Table.States (989), 37, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (989), 41, 13);
- Add_Action (Table.States (989), 48, 16);
- Add_Action (Table.States (989), 52, 20);
- Add_Action (Table.States (989), 57, 21);
- Add_Action (Table.States (989), 58, 22);
- Add_Action (Table.States (989), 61, 24);
- Add_Action (Table.States (989), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (989), 93, 31);
- Add_Action (Table.States (989), 104, 360);
- Add_Action (Table.States (989), 105, 33);
- Add_Action (Table.States (989), 106, 34);
- Table.States (989).Goto_List.Set_Capacity (31);
- Add_Goto (Table.States (989), 113, 36);
- Add_Goto (Table.States (989), 123, 38);
- Add_Goto (Table.States (989), 126, 39);
- Add_Goto (Table.States (989), 128, 41);
- Add_Goto (Table.States (989), 131, 42);
- Add_Goto (Table.States (989), 132, 43);
- Add_Goto (Table.States (989), 133, 44);
- Add_Goto (Table.States (989), 139, 47);
- Add_Goto (Table.States (989), 151, 50);
- Add_Goto (Table.States (989), 152, 51);
- Add_Goto (Table.States (989), 161, 53);
- Add_Goto (Table.States (989), 190, 57);
- Add_Goto (Table.States (989), 196, 59);
- Add_Goto (Table.States (989), 217, 68);
- Add_Goto (Table.States (989), 222, 70);
- Add_Goto (Table.States (989), 232, 72);
- Add_Goto (Table.States (989), 239, 73);
- Add_Goto (Table.States (989), 257, 83);
- Add_Goto (Table.States (989), 261, 86);
- Add_Goto (Table.States (989), 272, 92);
- Add_Goto (Table.States (989), 276, 93);
- Add_Goto (Table.States (989), 290, 96);
- Add_Goto (Table.States (989), 293, 97);
- Add_Goto (Table.States (989), 294, 98);
- Add_Goto (Table.States (989), 298, 99);
- Add_Goto (Table.States (989), 299, 361);
- Add_Goto (Table.States (989), 300, 1107);
- Add_Goto (Table.States (989), 302, 100);
- Add_Goto (Table.States (989), 303, 101);
- Add_Goto (Table.States (989), 306, 363);
- Add_Goto (Table.States (989), 323, 114);
- Table.States (989).Kernel := To_Vector ((0 => (174, 68, 0,
False)));
- Table.States (989).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 300, 0)));
- Table.States (990).Action_List.Set_Capacity (46);
- Add_Action (Table.States (990), (4, 5, 13, 15, 17, 18, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (222, 3), 7, if_statement_3'Access, null);
- Table.States (990).Kernel := To_Vector ((0 => (222, 96, 0,
False)));
- Table.States (990).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 222, 7)));
- Table.States (991).Action_List.Set_Capacity (1);
- Add_Action (Table.States (991), 24, 1108);
- Table.States (991).Kernel := To_Vector ((0 => (222, 300, 3,
False)));
- Table.States (991).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1108)));
- Table.States (992).Action_List.Set_Capacity (1);
- Add_Action (Table.States (992), 96, 1109);
- Table.States (992).Kernel := To_Vector ((0 => (222, 32, 1,
False)));
- Table.States (992).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1109)));
- Table.States (993).Action_List.Set_Capacity (40);
- Add_Action (Table.States (993), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (248, 0), 7,
- package_body_stub_0'Access, null);
- Table.States (993).Kernel := To_Vector ((0 => (248, 96, 0,
False)));
- Table.States (993).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 248, 7)));
- Table.States (994).Action_List.Set_Capacity (24);
- Add_Action (Table.States (994), 4, 1);
- Add_Action (Table.States (994), 5, 2);
- Add_Action (Table.States (994), 13, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (994), 15, 3);
- Add_Action (Table.States (994), 17, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (994), 18, 4);
- Add_Action (Table.States (994), 24, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (994), 26, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (994), 27, 5);
- Add_Action (Table.States (994), 28, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (994), 31, 9);
- Add_Action (Table.States (994), 32, 10);
- Add_Action (Table.States (994), 37, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (994), 41, 13);
- Add_Action (Table.States (994), 48, 16);
- Add_Action (Table.States (994), 52, 20);
- Add_Action (Table.States (994), 57, 21);
- Add_Action (Table.States (994), 58, 22);
- Add_Action (Table.States (994), 61, 24);
- Add_Action (Table.States (994), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (994), 93, 31);
- Add_Action (Table.States (994), 104, 360);
- Add_Action (Table.States (994), 105, 33);
- Add_Action (Table.States (994), 106, 34);
- Table.States (994).Goto_List.Set_Capacity (32);
- Add_Goto (Table.States (994), 113, 36);
- Add_Goto (Table.States (994), 123, 38);
- Add_Goto (Table.States (994), 126, 39);
- Add_Goto (Table.States (994), 128, 41);
- Add_Goto (Table.States (994), 131, 42);
- Add_Goto (Table.States (994), 132, 43);
- Add_Goto (Table.States (994), 133, 44);
- Add_Goto (Table.States (994), 139, 47);
- Add_Goto (Table.States (994), 151, 50);
- Add_Goto (Table.States (994), 152, 51);
- Add_Goto (Table.States (994), 161, 53);
- Add_Goto (Table.States (994), 190, 57);
- Add_Goto (Table.States (994), 196, 59);
- Add_Goto (Table.States (994), 217, 68);
- Add_Goto (Table.States (994), 218, 1110);
- Add_Goto (Table.States (994), 222, 70);
- Add_Goto (Table.States (994), 232, 72);
- Add_Goto (Table.States (994), 239, 73);
- Add_Goto (Table.States (994), 257, 83);
- Add_Goto (Table.States (994), 261, 86);
- Add_Goto (Table.States (994), 272, 92);
- Add_Goto (Table.States (994), 276, 93);
- Add_Goto (Table.States (994), 290, 96);
- Add_Goto (Table.States (994), 293, 97);
- Add_Goto (Table.States (994), 294, 98);
- Add_Goto (Table.States (994), 298, 99);
- Add_Goto (Table.States (994), 299, 361);
- Add_Goto (Table.States (994), 300, 390);
- Add_Goto (Table.States (994), 302, 100);
- Add_Goto (Table.States (994), 303, 101);
- Add_Goto (Table.States (994), 306, 363);
- Add_Goto (Table.States (994), 323, 114);
- Table.States (994).Kernel := To_Vector ((0 => (247, 13, 2,
False)));
- Table.States (994).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 218, 0)));
- Table.States (995).Action_List.Set_Capacity (4);
- Add_Action (Table.States (995), 96, Reduce, (240, 1), 0, null,
null);
- Add_Action (Table.States (995), 104, 119);
- Add_Action (Table.States (995), 105, 33);
- Add_Action (Table.States (995), 106, 34);
- Table.States (995).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (995), 128, 41);
- Add_Goto (Table.States (995), 239, 632);
- Add_Goto (Table.States (995), 240, 1111);
- Add_Goto (Table.States (995), 272, 92);
- Add_Goto (Table.States (995), 293, 97);
- Table.States (995).Kernel := To_Vector ((0 => (247, 24, 1,
False)));
- Table.States (995).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 240, 0)));
- Table.States (996).Action_List.Set_Capacity (40);
- Add_Action (Table.States (996), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (213, 0), 7,
- generic_instantiation_0'Access, null);
- Table.States (996).Kernel := To_Vector ((0 => (213, 96, 0,
False)));
- Table.States (996).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 213, 7)));
+ Table.States (995).Kernel := To_Vector ((0 => (199, 97, 0,
False)));
+ Table.States (995).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 199, 6)));
+ Table.States (996).Action_List.Set_Capacity (15);
+ Add_Action (Table.States (996), 3, 122);
+ Add_Action (Table.States (996), 39, 123);
+ Add_Action (Table.States (996), 40, 124);
+ Add_Action (Table.States (996), 41, 125);
+ Add_Action (Table.States (996), 52, 126);
+ Add_Action (Table.States (996), 74, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (996), 76, 127);
+ Add_Action (Table.States (996), 79, 31);
+ Add_Action (Table.States (996), 95, 128);
+ Add_Action (Table.States (996), 96, 129);
+ Add_Action (Table.States (996), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (996), 104, 130);
+ Add_Action (Table.States (996), 105, 120);
+ Add_Action (Table.States (996), 106, 34);
+ Add_Action (Table.States (996), 107, 35);
+ Table.States (996).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (996), 118, 131);
+ Add_Goto (Table.States (996), 129, 42);
+ Add_Goto (Table.States (996), 192, 132);
+ Add_Goto (Table.States (996), 193, 1115);
+ Add_Goto (Table.States (996), 198, 134);
+ Add_Goto (Table.States (996), 240, 135);
+ Add_Goto (Table.States (996), 259, 136);
+ Add_Goto (Table.States (996), 273, 93);
+ Add_Goto (Table.States (996), 276, 137);
+ Add_Goto (Table.States (996), 283, 138);
+ Add_Goto (Table.States (996), 284, 139);
+ Add_Goto (Table.States (996), 285, 140);
+ Add_Goto (Table.States (996), 286, 141);
+ Add_Goto (Table.States (996), 287, 142);
+ Add_Goto (Table.States (996), 288, 143);
+ Add_Goto (Table.States (996), 294, 98);
+ Add_Goto (Table.States (996), 302, 144);
+ Add_Goto (Table.States (996), 321, 145);
+ Add_Goto (Table.States (996), 322, 146);
+ Add_Goto (Table.States (996), 331, 147);
+ Table.States (996).Kernel := To_Vector ((0 => (199, 83, 1,
False)));
+ Table.States (996).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
Table.States (997).Action_List.Set_Capacity (1);
- Add_Action (Table.States (997), (1 => 96), (251, 1), 7,
package_specification_1'Access,
- package_specification_1_check'Access);
- Table.States (997).Kernel := To_Vector ((0 => (251, 240, 0,
False)));
- Table.States (997).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 251, 7)));
+ Add_Action (Table.States (997), 97, 1116);
+ Table.States (997).Kernel := To_Vector ((0 => (199, 123, 1,
False)));
+ Table.States (997).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1116)));
Table.States (998).Action_List.Set_Capacity (1);
- Add_Action (Table.States (998), 24, 1112);
- Table.States (998).Kernel := To_Vector ((0 => (251, 159, 1,
False)));
- Table.States (998).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1112)));
- Table.States (999).Action_List.Set_Capacity (40);
- Add_Action (Table.States (999), (4, 5, 13, 15, 17, 18, 24, 25, 27,
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (265, 0), 7,
- protected_body_stub_0'Access, null);
- Table.States (999).Kernel := To_Vector ((0 => (265, 96, 0,
False)));
- Table.States (999).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 265, 7)));
- Table.States (1000).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1000), 72, Reduce, (253, 1), 0, null,
null);
- Add_Action (Table.States (1000), 76, 1113);
- Table.States (1000).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (1000), 177, 1114);
- Add_Goto (Table.States (1000), 199, 344);
- Add_Goto (Table.States (1000), 253, 1115);
- Table.States (1000).Kernel := To_Vector ((0 => (176, 104, 5,
False)));
- Table.States (1000).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 177, 0)));
- Table.States (1001).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1001), 35, Reduce, (122, 1), 0, null,
null);
- Add_Action (Table.States (1001), 74, 337);
- Add_Action (Table.States (1001), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (1001).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (1001), 122, 430);
- Table.States (1001).Kernel := To_Vector (((307, 312, 4, False),
(309, 312, 1, False)));
- Table.States (1001).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (1002).Action_List.Set_Capacity (7);
- Add_Action (Table.States (1002), (24, 25, 28, 29, 40, 46, 50),
(268, 0), 2, null, null);
- Table.States (1002).Kernel := To_Vector ((0 => (268, 267, 0,
True)));
- Table.States (1002).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 268, 2)));
- Table.States (1002).Minimal_Complete_Actions_Recursive := True;
- Table.States (1003).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1003), 96, Reduce, (220, 1), 0, null,
null);
- Add_Action (Table.States (1003), 104, 149);
- Table.States (1003).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (1003), 220, 1116);
- Table.States (1003).Kernel := To_Vector ((0 => (264, 24, 1,
False)));
- Table.States (1003).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 220, 0)));
- Table.States (1004).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1004), 104, 119);
- Add_Action (Table.States (1004), 105, 33);
+ Add_Action (Table.States (998), 32, 1117);
+ Table.States (998).Kernel := To_Vector ((0 => (223, 24, 2,
False)));
+ Table.States (998).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 32, 1117)));
+ Table.States (999).Action_List.Set_Capacity (26);
+ Add_Action (Table.States (999), 4, 1);
+ Add_Action (Table.States (999), 5, 2);
+ Add_Action (Table.States (999), 13, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (999), 15, 3);
+ Add_Action (Table.States (999), 17, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (999), 18, 4);
+ Add_Action (Table.States (999), 22, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (999), 23, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (999), 24, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (999), 27, 5);
+ Add_Action (Table.States (999), 28, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (999), 31, 9);
+ Add_Action (Table.States (999), 32, 10);
+ Add_Action (Table.States (999), 37, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (999), 41, 13);
+ Add_Action (Table.States (999), 48, 16);
+ Add_Action (Table.States (999), 52, 20);
+ Add_Action (Table.States (999), 57, 21);
+ Add_Action (Table.States (999), 58, 22);
+ Add_Action (Table.States (999), 61, 24);
+ Add_Action (Table.States (999), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (999), 79, 31);
+ Add_Action (Table.States (999), 94, 32);
+ Add_Action (Table.States (999), 105, 361);
+ Add_Action (Table.States (999), 106, 34);
+ Add_Action (Table.States (999), 107, 35);
+ Table.States (999).Goto_List.Set_Capacity (31);
+ Add_Goto (Table.States (999), 114, 37);
+ Add_Goto (Table.States (999), 124, 39);
+ Add_Goto (Table.States (999), 127, 40);
+ Add_Goto (Table.States (999), 129, 42);
+ Add_Goto (Table.States (999), 132, 43);
+ Add_Goto (Table.States (999), 133, 44);
+ Add_Goto (Table.States (999), 134, 45);
+ Add_Goto (Table.States (999), 140, 48);
+ Add_Goto (Table.States (999), 152, 51);
+ Add_Goto (Table.States (999), 153, 52);
+ Add_Goto (Table.States (999), 162, 54);
+ Add_Goto (Table.States (999), 191, 58);
+ Add_Goto (Table.States (999), 197, 60);
+ Add_Goto (Table.States (999), 218, 69);
+ Add_Goto (Table.States (999), 223, 71);
+ Add_Goto (Table.States (999), 233, 73);
+ Add_Goto (Table.States (999), 240, 74);
+ Add_Goto (Table.States (999), 258, 84);
+ Add_Goto (Table.States (999), 262, 87);
+ Add_Goto (Table.States (999), 273, 93);
+ Add_Goto (Table.States (999), 277, 94);
+ Add_Goto (Table.States (999), 291, 97);
+ Add_Goto (Table.States (999), 294, 98);
+ Add_Goto (Table.States (999), 295, 99);
+ Add_Goto (Table.States (999), 299, 100);
+ Add_Goto (Table.States (999), 300, 362);
+ Add_Goto (Table.States (999), 301, 1118);
+ Add_Goto (Table.States (999), 303, 101);
+ Add_Goto (Table.States (999), 304, 102);
+ Add_Goto (Table.States (999), 307, 364);
+ Add_Goto (Table.States (999), 324, 115);
+ Table.States (999).Kernel := To_Vector ((0 => (175, 68, 0,
False)));
+ Table.States (999).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 301, 0)));
+ Table.States (1000).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (1000), (4, 5, 13, 15, 17, 18, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (223, 3), 7, if_statement_3'Access, null);
+ Table.States (1000).Kernel := To_Vector ((0 => (223, 97, 0,
False)));
+ Table.States (1000).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 223, 7)));
+ end Subr_17;
+ procedure Subr_18
+ is begin
+ Table.States (1001).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1001), 24, 1119);
+ Table.States (1001).Kernel := To_Vector ((0 => (223, 301, 3,
False)));
+ Table.States (1001).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1119)));
+ Table.States (1002).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1002), 97, 1120);
+ Table.States (1002).Kernel := To_Vector ((0 => (223, 32, 1,
False)));
+ Table.States (1002).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1120)));
+ Table.States (1003).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1003), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (249, 0), 7,
+ package_body_stub_0'Access, null);
+ Table.States (1003).Kernel := To_Vector ((0 => (249, 97, 0,
False)));
+ Table.States (1003).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 249, 7)));
+ Table.States (1004).Action_List.Set_Capacity (25);
+ Add_Action (Table.States (1004), 4, 1);
+ Add_Action (Table.States (1004), 5, 2);
+ Add_Action (Table.States (1004), 13, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (1004), 15, 3);
+ Add_Action (Table.States (1004), 17, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (1004), 18, 4);
+ Add_Action (Table.States (1004), 24, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (1004), 26, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (1004), 27, 5);
+ Add_Action (Table.States (1004), 28, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (1004), 31, 9);
+ Add_Action (Table.States (1004), 32, 10);
+ Add_Action (Table.States (1004), 37, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (1004), 41, 13);
+ Add_Action (Table.States (1004), 48, 16);
+ Add_Action (Table.States (1004), 52, 20);
+ Add_Action (Table.States (1004), 57, 21);
+ Add_Action (Table.States (1004), 58, 22);
+ Add_Action (Table.States (1004), 61, 24);
+ Add_Action (Table.States (1004), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (1004), 79, 31);
+ Add_Action (Table.States (1004), 94, 32);
+ Add_Action (Table.States (1004), 105, 361);
Add_Action (Table.States (1004), 106, 34);
- Table.States (1004).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (1004), 128, 41);
- Add_Goto (Table.States (1004), 227, 1117);
- Add_Goto (Table.States (1004), 239, 842);
- Add_Goto (Table.States (1004), 272, 92);
- Add_Goto (Table.States (1004), 293, 97);
- Table.States (1004).Kernel := To_Vector ((0 => (271, 39, 4,
False)));
- Table.States (1004).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (1005).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1005), 96, 1118);
- Table.States (1005).Kernel := To_Vector ((0 => (271, 266, 1,
False)));
- Table.States (1005).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1118)));
- Table.States (1006).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1006), 104, 119);
- Add_Action (Table.States (1006), 105, 33);
- Add_Action (Table.States (1006), 106, 34);
- Table.States (1006).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (1006), 128, 41);
- Add_Goto (Table.States (1006), 239, 1119);
- Add_Goto (Table.States (1006), 272, 92);
- Add_Goto (Table.States (1006), 293, 97);
- Table.States (1006).Kernel := To_Vector ((0 => (227, 10, 1,
True)));
- Table.States (1006).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (1006).Minimal_Complete_Actions_Recursive := True;
- Table.States (1007).Action_List.Set_Capacity (17);
- Add_Action (Table.States (1007), 24, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (1007), 25, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (1007), 28, 183);
- Add_Action (Table.States (1007), 29, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (1007), 30, 8);
- Add_Action (Table.States (1007), 40, 12);
- Add_Action (Table.States (1007), 46, 14);
- Add_Action (Table.States (1007), 47, 15);
- Add_Action (Table.States (1007), 48, 16);
- Add_Action (Table.States (1007), 49, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (1007), 50, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (1007), 51, 19);
- Add_Action (Table.States (1007), 63, 25);
- Add_Action (Table.States (1007), 66, 26);
- Add_Action (Table.States (1007), 69, 27);
- Add_Action (Table.States (1007), 71, 28);
- Add_Action (Table.States (1007), 104, 185);
- Table.States (1007).Goto_List.Set_Capacity (54);
- Add_Goto (Table.States (1007), 112, 35);
- Add_Goto (Table.States (1007), 121, 37);
- Add_Goto (Table.States (1007), 127, 40);
- Add_Goto (Table.States (1007), 134, 45);
- Add_Goto (Table.States (1007), 135, 46);
- Add_Goto (Table.States (1007), 157, 391);
- Add_Goto (Table.States (1007), 158, 392);
- Add_Goto (Table.States (1007), 159, 669);
- Add_Goto (Table.States (1007), 179, 54);
- Add_Goto (Table.States (1007), 182, 55);
- Add_Goto (Table.States (1007), 186, 56);
- Add_Goto (Table.States (1007), 193, 58);
- Add_Goto (Table.States (1007), 206, 60);
- Add_Goto (Table.States (1007), 207, 61);
- Add_Goto (Table.States (1007), 209, 62);
- Add_Goto (Table.States (1007), 210, 63);
- Add_Goto (Table.States (1007), 213, 64);
- Add_Goto (Table.States (1007), 214, 65);
- Add_Goto (Table.States (1007), 215, 66);
- Add_Goto (Table.States (1007), 216, 67);
- Add_Goto (Table.States (1007), 219, 69);
- Add_Goto (Table.States (1007), 223, 71);
- Add_Goto (Table.States (1007), 243, 74);
- Add_Goto (Table.States (1007), 244, 75);
- Add_Goto (Table.States (1007), 245, 76);
- Add_Goto (Table.States (1007), 246, 77);
- Add_Goto (Table.States (1007), 247, 78);
- Add_Goto (Table.States (1007), 248, 79);
- Add_Goto (Table.States (1007), 249, 80);
- Add_Goto (Table.States (1007), 250, 81);
- Add_Goto (Table.States (1007), 251, 82);
- Add_Goto (Table.States (1007), 257, 394);
- Add_Goto (Table.States (1007), 259, 84);
- Add_Goto (Table.States (1007), 260, 85);
- Add_Goto (Table.States (1007), 262, 87);
- Add_Goto (Table.States (1007), 263, 88);
- Add_Goto (Table.States (1007), 264, 89);
- Add_Goto (Table.States (1007), 265, 90);
- Add_Goto (Table.States (1007), 266, 1120);
- Add_Goto (Table.States (1007), 271, 91);
- Add_Goto (Table.States (1007), 281, 94);
- Add_Goto (Table.States (1007), 289, 95);
- Add_Goto (Table.States (1007), 304, 102);
- Add_Goto (Table.States (1007), 305, 103);
- Add_Goto (Table.States (1007), 307, 105);
- Add_Goto (Table.States (1007), 308, 106);
- Add_Goto (Table.States (1007), 309, 107);
- Add_Goto (Table.States (1007), 311, 108);
- Add_Goto (Table.States (1007), 313, 109);
- Add_Goto (Table.States (1007), 316, 111);
- Add_Goto (Table.States (1007), 317, 112);
- Add_Goto (Table.States (1007), 319, 113);
- Add_Goto (Table.States (1007), 325, 115);
- Add_Goto (Table.States (1007), 331, 116);
- Table.States (1007).Kernel := To_Vector ((0 => (304, 74, 2,
False)));
- Table.States (1007).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 159, 0)));
+ Add_Action (Table.States (1004), 107, 35);
+ Table.States (1004).Goto_List.Set_Capacity (32);
+ Add_Goto (Table.States (1004), 114, 37);
+ Add_Goto (Table.States (1004), 124, 39);
+ Add_Goto (Table.States (1004), 127, 40);
+ Add_Goto (Table.States (1004), 129, 42);
+ Add_Goto (Table.States (1004), 132, 43);
+ Add_Goto (Table.States (1004), 133, 44);
+ Add_Goto (Table.States (1004), 134, 45);
+ Add_Goto (Table.States (1004), 140, 48);
+ Add_Goto (Table.States (1004), 152, 51);
+ Add_Goto (Table.States (1004), 153, 52);
+ Add_Goto (Table.States (1004), 162, 54);
+ Add_Goto (Table.States (1004), 191, 58);
+ Add_Goto (Table.States (1004), 197, 60);
+ Add_Goto (Table.States (1004), 218, 69);
+ Add_Goto (Table.States (1004), 219, 1121);
+ Add_Goto (Table.States (1004), 223, 71);
+ Add_Goto (Table.States (1004), 233, 73);
+ Add_Goto (Table.States (1004), 240, 74);
+ Add_Goto (Table.States (1004), 258, 84);
+ Add_Goto (Table.States (1004), 262, 87);
+ Add_Goto (Table.States (1004), 273, 93);
+ Add_Goto (Table.States (1004), 277, 94);
+ Add_Goto (Table.States (1004), 291, 97);
+ Add_Goto (Table.States (1004), 294, 98);
+ Add_Goto (Table.States (1004), 295, 99);
+ Add_Goto (Table.States (1004), 299, 100);
+ Add_Goto (Table.States (1004), 300, 362);
+ Add_Goto (Table.States (1004), 301, 391);
+ Add_Goto (Table.States (1004), 303, 101);
+ Add_Goto (Table.States (1004), 304, 102);
+ Add_Goto (Table.States (1004), 307, 364);
+ Add_Goto (Table.States (1004), 324, 115);
+ Table.States (1004).Kernel := To_Vector ((0 => (248, 13, 2,
False)));
+ Table.States (1004).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 219, 0)));
+ Table.States (1005).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (1005), 79, 31);
+ Add_Action (Table.States (1005), 97, Reduce, (241, 1), 0, null,
null);
+ Add_Action (Table.States (1005), 105, 120);
+ Add_Action (Table.States (1005), 106, 34);
+ Add_Action (Table.States (1005), 107, 35);
+ Table.States (1005).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (1005), 129, 42);
+ Add_Goto (Table.States (1005), 240, 638);
+ Add_Goto (Table.States (1005), 241, 1122);
+ Add_Goto (Table.States (1005), 273, 93);
+ Add_Goto (Table.States (1005), 294, 98);
+ Table.States (1005).Kernel := To_Vector ((0 => (248, 24, 1,
False)));
+ Table.States (1005).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 241, 0)));
+ Table.States (1006).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1006), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (214, 0), 7,
+ generic_instantiation_0'Access, null);
+ Table.States (1006).Kernel := To_Vector ((0 => (214, 97, 0,
False)));
+ Table.States (1006).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 214, 7)));
+ Table.States (1007).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1007), (1 => 97), (252, 1), 7,
package_specification_1'Access,
+ package_specification_1_check'Access);
+ Table.States (1007).Kernel := To_Vector ((0 => (252, 241, 0,
False)));
+ Table.States (1007).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 252, 7)));
Table.States (1008).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1008), (1 => 96), (266, 1), 3,
protected_definition_1'Access,
- protected_definition_1_check'Access);
- Table.States (1008).Kernel := To_Vector ((0 => (266, 220, 0,
False)));
- Table.States (1008).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 266, 3)));
- Table.States (1009).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1009), 24, 1121);
- Table.States (1009).Kernel := To_Vector ((0 => (266, 159, 1,
False)));
- Table.States (1009).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1121)));
- Table.States (1010).Action_List.Set_Capacity (14);
- Add_Action (Table.States (1010), 3, 121);
- Add_Action (Table.States (1010), 21, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (1010), 39, 122);
- Add_Action (Table.States (1010), 40, 123);
- Add_Action (Table.States (1010), 41, 124);
- Add_Action (Table.States (1010), 52, 125);
- Add_Action (Table.States (1010), 76, 126);
- Add_Action (Table.States (1010), 94, 127);
- Add_Action (Table.States (1010), 95, 128);
- Add_Action (Table.States (1010), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (1010), 103, 129);
- Add_Action (Table.States (1010), 104, 119);
- Add_Action (Table.States (1010), 105, 33);
- Add_Action (Table.States (1010), 106, 34);
- Table.States (1010).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (1010), 117, 130);
- Add_Goto (Table.States (1010), 128, 41);
- Add_Goto (Table.States (1010), 191, 131);
- Add_Goto (Table.States (1010), 192, 1122);
- Add_Goto (Table.States (1010), 197, 133);
- Add_Goto (Table.States (1010), 239, 134);
- Add_Goto (Table.States (1010), 258, 135);
- Add_Goto (Table.States (1010), 272, 92);
- Add_Goto (Table.States (1010), 275, 136);
- Add_Goto (Table.States (1010), 282, 137);
- Add_Goto (Table.States (1010), 283, 138);
- Add_Goto (Table.States (1010), 284, 139);
- Add_Goto (Table.States (1010), 285, 140);
- Add_Goto (Table.States (1010), 286, 141);
- Add_Goto (Table.States (1010), 287, 142);
- Add_Goto (Table.States (1010), 293, 97);
- Add_Goto (Table.States (1010), 301, 143);
- Add_Goto (Table.States (1010), 320, 144);
- Add_Goto (Table.States (1010), 321, 145);
- Add_Goto (Table.States (1010), 330, 146);
- Table.States (1010).Kernel := To_Vector ((0 => (194, 82, 0,
False)));
- Table.States (1010).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (1011).Action_List.Set_Capacity (46);
- Add_Action (Table.States (1011), (4, 5, 13, 15, 17, 18, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (196, 0), 7, extended_return_statement_0'Access, null);
- Table.States (1011).Kernel := To_Vector ((0 => (196, 96, 0,
False)));
- Table.States (1011).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 196, 7)));
- Table.States (1012).Action_List.Set_Capacity (6);
- Add_Action (Table.States (1012), 35, Reduce, (122, 1), 0, null,
null);
- Add_Action (Table.States (1012), 74, 337);
- Add_Action (Table.States (1012), 76, 235);
- Add_Action (Table.States (1012), 84, 237);
- Add_Action (Table.States (1012), 101, 239);
- Add_Action (Table.States (1012), 102, 240);
- Table.States (1012).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (1012), 115, 241);
- Add_Goto (Table.States (1012), 122, 511);
- Add_Goto (Table.States (1012), 322, 242);
- Table.States (1012).Kernel := To_Vector (((128, 239, 2, True),
(239, 239, 5, True), (239, 239, 2, True),
- (247, 239, 4, False), (247, 239, 3, False), (272, 239, 3, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True), (293, 239, 2, True)));
- Table.States (1012).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
+ Add_Action (Table.States (1008), 24, 1123);
+ Table.States (1008).Kernel := To_Vector ((0 => (252, 160, 1,
False)));
+ Table.States (1008).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1123)));
+ Table.States (1009).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1009), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (266, 0), 7,
+ protected_body_stub_0'Access, null);
+ Table.States (1009).Kernel := To_Vector ((0 => (266, 97, 0,
False)));
+ Table.States (1009).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 266, 7)));
+ Table.States (1010).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1010), 72, Reduce, (254, 1), 0, null,
null);
+ Add_Action (Table.States (1010), 76, 1124);
+ Table.States (1010).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (1010), 178, 1125);
+ Add_Goto (Table.States (1010), 200, 345);
+ Add_Goto (Table.States (1010), 254, 1126);
+ Table.States (1010).Kernel := To_Vector ((0 => (177, 105, 5,
False)));
+ Table.States (1010).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 178, 0)));
+ Table.States (1011).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (1011), 35, Reduce, (123, 1), 0, null,
null);
+ Add_Action (Table.States (1011), 74, 338);
+ Add_Action (Table.States (1011), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (1011).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (1011), 123, 431);
+ Table.States (1011).Kernel := To_Vector (((308, 313, 4, False),
(310, 313, 1, False)));
+ Table.States (1011).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (1012).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (1012), (24, 25, 28, 29, 40, 46, 50),
(269, 0), 2, null, null);
+ Table.States (1012).Kernel := To_Vector ((0 => (269, 268, 0,
True)));
+ Table.States (1012).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 269, 2)));
+ Table.States (1012).Minimal_Complete_Actions_Recursive := True;
Table.States (1013).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1013), 35, Reduce, (122, 1), 0, null,
null);
- Add_Action (Table.States (1013), 74, 337);
+ Add_Action (Table.States (1013), 97, Reduce, (221, 1), 0, null,
null);
+ Add_Action (Table.States (1013), 105, 150);
Table.States (1013).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (1013), 122, 520);
- Table.States (1013).Kernel := To_Vector ((0 => (264, 104, 3,
False)));
- Table.States (1013).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (1014).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1014), 35, Reduce, (122, 1), 0, null,
null);
- Add_Action (Table.States (1014), 74, 337);
- Table.States (1014).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (1014), 122, 540);
- Table.States (1014).Kernel := To_Vector ((0 => (316, 104, 4,
False)));
- Table.States (1014).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
+ Add_Goto (Table.States (1013), 221, 1127);
+ Table.States (1013).Kernel := To_Vector ((0 => (265, 24, 1,
False)));
+ Table.States (1013).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 221, 0)));
+ Table.States (1014).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (1014), 79, 31);
+ Add_Action (Table.States (1014), 105, 120);
+ Add_Action (Table.States (1014), 106, 34);
+ Add_Action (Table.States (1014), 107, 35);
+ Table.States (1014).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (1014), 129, 42);
+ Add_Goto (Table.States (1014), 228, 1128);
+ Add_Goto (Table.States (1014), 240, 850);
+ Add_Goto (Table.States (1014), 273, 93);
+ Add_Goto (Table.States (1014), 294, 98);
+ Table.States (1014).Kernel := To_Vector ((0 => (272, 39, 4,
False)));
+ Table.States (1014).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
Table.States (1015).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1015), 35, 587);
- Table.States (1015).Kernel := To_Vector ((0 => (307, 122, 4,
False)));
- Table.States (1015).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 587)));
- Table.States (1016).Action_List.Set_Capacity (46);
- Add_Action (Table.States (1016), (4, 5, 13, 15, 17, 18, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (152, 0), 7, conditional_entry_call_0'Access, null);
- Table.States (1016).Kernel := To_Vector ((0 => (152, 96, 0,
False)));
- Table.States (1016).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 152, 7)));
- Table.States (1017).Action_List.Set_Capacity (46);
- Add_Action (Table.States (1017), (4, 5, 13, 15, 17, 18, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (323, 0), 7, timed_entry_call_0'Access, null);
- Table.States (1017).Kernel := To_Vector ((0 => (323, 96, 0,
False)));
- Table.States (1017).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 323, 7)));
- Table.States (1018).Action_List.Set_Capacity (46);
- Add_Action (Table.States (1018), (4, 5, 13, 15, 17, 18, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (294, 0), 7, selective_accept_0'Access, null);
- Table.States (1018).Kernel := To_Vector ((0 => (294, 96, 0,
False)));
- Table.States (1018).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 294, 7)));
+ Add_Action (Table.States (1015), 97, 1129);
+ Table.States (1015).Kernel := To_Vector ((0 => (272, 267, 1,
False)));
+ Table.States (1015).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1129)));
+ Table.States (1016).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (1016), 79, 31);
+ Add_Action (Table.States (1016), 105, 120);
+ Add_Action (Table.States (1016), 106, 34);
+ Add_Action (Table.States (1016), 107, 35);
+ Table.States (1016).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (1016), 129, 42);
+ Add_Goto (Table.States (1016), 240, 1130);
+ Add_Goto (Table.States (1016), 273, 93);
+ Add_Goto (Table.States (1016), 294, 98);
+ Table.States (1016).Kernel := To_Vector ((0 => (228, 10, 1,
True)));
+ Table.States (1016).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (1016).Minimal_Complete_Actions_Recursive := True;
+ Table.States (1017).Action_List.Set_Capacity (17);
+ Add_Action (Table.States (1017), 24, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (1017), 25, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (1017), 28, 184);
+ Add_Action (Table.States (1017), 29, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (1017), 30, 8);
+ Add_Action (Table.States (1017), 40, 12);
+ Add_Action (Table.States (1017), 46, 14);
+ Add_Action (Table.States (1017), 47, 15);
+ Add_Action (Table.States (1017), 48, 16);
+ Add_Action (Table.States (1017), 49, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (1017), 50, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (1017), 51, 19);
+ Add_Action (Table.States (1017), 63, 25);
+ Add_Action (Table.States (1017), 66, 26);
+ Add_Action (Table.States (1017), 69, 27);
+ Add_Action (Table.States (1017), 71, 28);
+ Add_Action (Table.States (1017), 105, 186);
+ Table.States (1017).Goto_List.Set_Capacity (54);
+ Add_Goto (Table.States (1017), 113, 36);
+ Add_Goto (Table.States (1017), 122, 38);
+ Add_Goto (Table.States (1017), 128, 41);
+ Add_Goto (Table.States (1017), 135, 46);
+ Add_Goto (Table.States (1017), 136, 47);
+ Add_Goto (Table.States (1017), 158, 392);
+ Add_Goto (Table.States (1017), 159, 393);
+ Add_Goto (Table.States (1017), 160, 675);
+ Add_Goto (Table.States (1017), 180, 55);
+ Add_Goto (Table.States (1017), 183, 56);
+ Add_Goto (Table.States (1017), 187, 57);
+ Add_Goto (Table.States (1017), 194, 59);
+ Add_Goto (Table.States (1017), 207, 61);
+ Add_Goto (Table.States (1017), 208, 62);
+ Add_Goto (Table.States (1017), 210, 63);
+ Add_Goto (Table.States (1017), 211, 64);
+ Add_Goto (Table.States (1017), 214, 65);
+ Add_Goto (Table.States (1017), 215, 66);
+ Add_Goto (Table.States (1017), 216, 67);
+ Add_Goto (Table.States (1017), 217, 68);
+ Add_Goto (Table.States (1017), 220, 70);
+ Add_Goto (Table.States (1017), 224, 72);
+ Add_Goto (Table.States (1017), 244, 75);
+ Add_Goto (Table.States (1017), 245, 76);
+ Add_Goto (Table.States (1017), 246, 77);
+ Add_Goto (Table.States (1017), 247, 78);
+ Add_Goto (Table.States (1017), 248, 79);
+ Add_Goto (Table.States (1017), 249, 80);
+ Add_Goto (Table.States (1017), 250, 81);
+ Add_Goto (Table.States (1017), 251, 82);
+ Add_Goto (Table.States (1017), 252, 83);
+ Add_Goto (Table.States (1017), 258, 395);
+ Add_Goto (Table.States (1017), 260, 85);
+ Add_Goto (Table.States (1017), 261, 86);
+ Add_Goto (Table.States (1017), 263, 88);
+ Add_Goto (Table.States (1017), 264, 89);
+ Add_Goto (Table.States (1017), 265, 90);
+ Add_Goto (Table.States (1017), 266, 91);
+ Add_Goto (Table.States (1017), 267, 1131);
+ Add_Goto (Table.States (1017), 272, 92);
+ Add_Goto (Table.States (1017), 282, 95);
+ Add_Goto (Table.States (1017), 290, 96);
+ Add_Goto (Table.States (1017), 305, 103);
+ Add_Goto (Table.States (1017), 306, 104);
+ Add_Goto (Table.States (1017), 308, 106);
+ Add_Goto (Table.States (1017), 309, 107);
+ Add_Goto (Table.States (1017), 310, 108);
+ Add_Goto (Table.States (1017), 312, 109);
+ Add_Goto (Table.States (1017), 314, 110);
+ Add_Goto (Table.States (1017), 317, 112);
+ Add_Goto (Table.States (1017), 318, 113);
+ Add_Goto (Table.States (1017), 320, 114);
+ Add_Goto (Table.States (1017), 326, 116);
+ Add_Goto (Table.States (1017), 332, 117);
+ Table.States (1017).Kernel := To_Vector ((0 => (305, 74, 2,
False)));
+ Table.States (1017).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 160, 0)));
+ Table.States (1018).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1018), (1 => 97), (267, 1), 3,
protected_definition_1'Access,
+ protected_definition_1_check'Access);
+ Table.States (1018).Kernel := To_Vector ((0 => (267, 221, 0,
False)));
+ Table.States (1018).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 267, 3)));
Table.States (1019).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1019), 96, 1123);
- Table.States (1019).Kernel := To_Vector ((0 => (126, 61, 1,
False)));
- Table.States (1019).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1123)));
- Table.States (1020).Action_List.Set_Capacity (40);
- Add_Action (Table.States (1020), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (317, 0), 7,
- task_body_stub_0'Access, null);
- Table.States (1020).Kernel := To_Vector ((0 => (317, 96, 0,
False)));
- Table.States (1020).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 317, 7)));
- Table.States (1021).Action_List.Set_Capacity (24);
- Add_Action (Table.States (1021), 4, 1);
- Add_Action (Table.States (1021), 5, 2);
- Add_Action (Table.States (1021), 13, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (1021), 15, 3);
- Add_Action (Table.States (1021), 17, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (1021), 18, 4);
- Add_Action (Table.States (1021), 24, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (1021), 26, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (1021), 27, 5);
- Add_Action (Table.States (1021), 28, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (1021), 31, 9);
- Add_Action (Table.States (1021), 32, 10);
- Add_Action (Table.States (1021), 37, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (1021), 41, 13);
- Add_Action (Table.States (1021), 48, 16);
- Add_Action (Table.States (1021), 52, 20);
- Add_Action (Table.States (1021), 57, 21);
- Add_Action (Table.States (1021), 58, 22);
- Add_Action (Table.States (1021), 61, 24);
- Add_Action (Table.States (1021), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (1021), 93, 31);
- Add_Action (Table.States (1021), 104, 360);
- Add_Action (Table.States (1021), 105, 33);
- Add_Action (Table.States (1021), 106, 34);
- Table.States (1021).Goto_List.Set_Capacity (32);
- Add_Goto (Table.States (1021), 113, 36);
- Add_Goto (Table.States (1021), 123, 38);
- Add_Goto (Table.States (1021), 126, 39);
- Add_Goto (Table.States (1021), 128, 41);
- Add_Goto (Table.States (1021), 131, 42);
- Add_Goto (Table.States (1021), 132, 43);
- Add_Goto (Table.States (1021), 133, 44);
- Add_Goto (Table.States (1021), 139, 47);
- Add_Goto (Table.States (1021), 151, 50);
- Add_Goto (Table.States (1021), 152, 51);
- Add_Goto (Table.States (1021), 161, 53);
- Add_Goto (Table.States (1021), 190, 57);
- Add_Goto (Table.States (1021), 196, 59);
- Add_Goto (Table.States (1021), 217, 68);
- Add_Goto (Table.States (1021), 218, 1124);
- Add_Goto (Table.States (1021), 222, 70);
- Add_Goto (Table.States (1021), 232, 72);
- Add_Goto (Table.States (1021), 239, 73);
- Add_Goto (Table.States (1021), 257, 83);
- Add_Goto (Table.States (1021), 261, 86);
- Add_Goto (Table.States (1021), 272, 92);
- Add_Goto (Table.States (1021), 276, 93);
- Add_Goto (Table.States (1021), 290, 96);
- Add_Goto (Table.States (1021), 293, 97);
- Add_Goto (Table.States (1021), 294, 98);
- Add_Goto (Table.States (1021), 298, 99);
- Add_Goto (Table.States (1021), 299, 361);
- Add_Goto (Table.States (1021), 300, 390);
- Add_Goto (Table.States (1021), 302, 100);
- Add_Goto (Table.States (1021), 303, 101);
- Add_Goto (Table.States (1021), 306, 363);
- Add_Goto (Table.States (1021), 323, 114);
- Table.States (1021).Kernel := To_Vector ((0 => (316, 13, 2,
False)));
- Table.States (1021).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 218, 0)));
- Table.States (1022).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1022), 104, 119);
- Add_Action (Table.States (1022), 105, 33);
- Add_Action (Table.States (1022), 106, 34);
- Table.States (1022).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (1022), 128, 41);
- Add_Goto (Table.States (1022), 227, 1125);
- Add_Goto (Table.States (1022), 239, 842);
- Add_Goto (Table.States (1022), 272, 92);
- Add_Goto (Table.States (1022), 293, 97);
- Table.States (1022).Kernel := To_Vector ((0 => (319, 39, 4,
False)));
- Table.States (1022).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (1023).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1023), 24, 1126);
- Table.States (1023).Kernel := To_Vector ((0 => (319, 318, 2,
False)));
- Table.States (1023).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1126)));
- Table.States (1024).Action_List.Set_Capacity (17);
- Add_Action (Table.States (1024), 24, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (1024), 25, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (1024), 28, 183);
- Add_Action (Table.States (1024), 29, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (1024), 30, 8);
- Add_Action (Table.States (1024), 40, 12);
- Add_Action (Table.States (1024), 46, 14);
- Add_Action (Table.States (1024), 47, 15);
- Add_Action (Table.States (1024), 48, 16);
- Add_Action (Table.States (1024), 49, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (1024), 50, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (1024), 51, 19);
- Add_Action (Table.States (1024), 63, 25);
- Add_Action (Table.States (1024), 66, 26);
- Add_Action (Table.States (1024), 69, 27);
- Add_Action (Table.States (1024), 71, 28);
- Add_Action (Table.States (1024), 104, 185);
- Table.States (1024).Goto_List.Set_Capacity (54);
- Add_Goto (Table.States (1024), 112, 35);
- Add_Goto (Table.States (1024), 121, 37);
- Add_Goto (Table.States (1024), 127, 40);
- Add_Goto (Table.States (1024), 134, 45);
- Add_Goto (Table.States (1024), 135, 46);
- Add_Goto (Table.States (1024), 157, 391);
- Add_Goto (Table.States (1024), 158, 392);
- Add_Goto (Table.States (1024), 159, 694);
- Add_Goto (Table.States (1024), 179, 54);
- Add_Goto (Table.States (1024), 182, 55);
- Add_Goto (Table.States (1024), 186, 56);
- Add_Goto (Table.States (1024), 193, 58);
- Add_Goto (Table.States (1024), 206, 60);
- Add_Goto (Table.States (1024), 207, 61);
- Add_Goto (Table.States (1024), 209, 62);
- Add_Goto (Table.States (1024), 210, 63);
- Add_Goto (Table.States (1024), 213, 64);
- Add_Goto (Table.States (1024), 214, 65);
- Add_Goto (Table.States (1024), 215, 66);
- Add_Goto (Table.States (1024), 216, 67);
- Add_Goto (Table.States (1024), 219, 69);
- Add_Goto (Table.States (1024), 223, 71);
- Add_Goto (Table.States (1024), 243, 74);
- Add_Goto (Table.States (1024), 244, 75);
- Add_Goto (Table.States (1024), 245, 76);
- Add_Goto (Table.States (1024), 246, 77);
- Add_Goto (Table.States (1024), 247, 78);
- Add_Goto (Table.States (1024), 248, 79);
- Add_Goto (Table.States (1024), 249, 80);
- Add_Goto (Table.States (1024), 250, 81);
- Add_Goto (Table.States (1024), 251, 82);
- Add_Goto (Table.States (1024), 257, 394);
- Add_Goto (Table.States (1024), 259, 84);
- Add_Goto (Table.States (1024), 260, 85);
- Add_Goto (Table.States (1024), 262, 87);
- Add_Goto (Table.States (1024), 263, 88);
- Add_Goto (Table.States (1024), 264, 89);
- Add_Goto (Table.States (1024), 265, 90);
- Add_Goto (Table.States (1024), 271, 91);
- Add_Goto (Table.States (1024), 281, 94);
- Add_Goto (Table.States (1024), 289, 95);
- Add_Goto (Table.States (1024), 304, 102);
- Add_Goto (Table.States (1024), 305, 103);
- Add_Goto (Table.States (1024), 307, 105);
- Add_Goto (Table.States (1024), 308, 106);
- Add_Goto (Table.States (1024), 309, 107);
- Add_Goto (Table.States (1024), 311, 108);
- Add_Goto (Table.States (1024), 313, 109);
- Add_Goto (Table.States (1024), 316, 111);
- Add_Goto (Table.States (1024), 317, 112);
- Add_Goto (Table.States (1024), 318, 1127);
- Add_Goto (Table.States (1024), 319, 113);
- Add_Goto (Table.States (1024), 325, 115);
- Add_Goto (Table.States (1024), 331, 116);
- Table.States (1024).Kernel := To_Vector ((0 => (305, 74, 2,
False)));
- Table.States (1024).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 318, 0)));
- end Subr_17;
- procedure Subr_18
- is begin
+ Add_Action (Table.States (1019), 24, 1132);
+ Table.States (1019).Kernel := To_Vector ((0 => (267, 160, 1,
False)));
+ Table.States (1019).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1132)));
+ Table.States (1020).Action_List.Set_Capacity (15);
+ Add_Action (Table.States (1020), 3, 122);
+ Add_Action (Table.States (1020), 21, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (1020), 39, 123);
+ Add_Action (Table.States (1020), 40, 124);
+ Add_Action (Table.States (1020), 41, 125);
+ Add_Action (Table.States (1020), 52, 126);
+ Add_Action (Table.States (1020), 76, 127);
+ Add_Action (Table.States (1020), 79, 31);
+ Add_Action (Table.States (1020), 95, 128);
+ Add_Action (Table.States (1020), 96, 129);
+ Add_Action (Table.States (1020), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (1020), 104, 130);
+ Add_Action (Table.States (1020), 105, 120);
+ Add_Action (Table.States (1020), 106, 34);
+ Add_Action (Table.States (1020), 107, 35);
+ Table.States (1020).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (1020), 118, 131);
+ Add_Goto (Table.States (1020), 129, 42);
+ Add_Goto (Table.States (1020), 192, 132);
+ Add_Goto (Table.States (1020), 193, 1133);
+ Add_Goto (Table.States (1020), 198, 134);
+ Add_Goto (Table.States (1020), 240, 135);
+ Add_Goto (Table.States (1020), 259, 136);
+ Add_Goto (Table.States (1020), 273, 93);
+ Add_Goto (Table.States (1020), 276, 137);
+ Add_Goto (Table.States (1020), 283, 138);
+ Add_Goto (Table.States (1020), 284, 139);
+ Add_Goto (Table.States (1020), 285, 140);
+ Add_Goto (Table.States (1020), 286, 141);
+ Add_Goto (Table.States (1020), 287, 142);
+ Add_Goto (Table.States (1020), 288, 143);
+ Add_Goto (Table.States (1020), 294, 98);
+ Add_Goto (Table.States (1020), 302, 144);
+ Add_Goto (Table.States (1020), 321, 145);
+ Add_Goto (Table.States (1020), 322, 146);
+ Add_Goto (Table.States (1020), 331, 147);
+ Table.States (1020).Kernel := To_Vector ((0 => (195, 83, 0,
False)));
+ Table.States (1020).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (1021).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (1021), (4, 5, 13, 15, 17, 18, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (197, 0), 7, extended_return_statement_0'Access, null);
+ Table.States (1021).Kernel := To_Vector ((0 => (197, 97, 0,
False)));
+ Table.States (1021).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 197, 7)));
+ Table.States (1022).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (1022), 35, Reduce, (123, 1), 0, null,
null);
+ Add_Action (Table.States (1022), 74, 338);
+ Add_Action (Table.States (1022), 76, 236);
+ Add_Action (Table.States (1022), 85, 238);
+ Add_Action (Table.States (1022), 102, 240);
+ Add_Action (Table.States (1022), 103, 241);
+ Table.States (1022).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (1022), 116, 242);
+ Add_Goto (Table.States (1022), 123, 514);
+ Add_Goto (Table.States (1022), 323, 243);
+ Table.States (1022).Kernel := To_Vector (((129, 240, 2, True),
(240, 240, 5, True), (240, 240, 2, True),
+ (248, 240, 4, False), (248, 240, 3, False), (273, 240, 3, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True), (294, 240, 2, True)));
+ Table.States (1022).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (1023).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1023), 35, Reduce, (123, 1), 0, null,
null);
+ Add_Action (Table.States (1023), 74, 338);
+ Table.States (1023).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (1023), 123, 524);
+ Table.States (1023).Kernel := To_Vector ((0 => (265, 105, 3,
False)));
+ Table.States (1023).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (1024).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1024), 35, Reduce, (123, 1), 0, null,
null);
+ Add_Action (Table.States (1024), 74, 338);
+ Table.States (1024).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (1024), 123, 544);
+ Table.States (1024).Kernel := To_Vector ((0 => (317, 105, 4,
False)));
+ Table.States (1024).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
Table.States (1025).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1025), (1 => 24), (318, 0), 3,
task_definition_0'Access, null);
- Table.States (1025).Kernel := To_Vector ((0 => (318, 159, 0,
False)));
- Table.States (1025).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 318, 3)));
- Table.States (1026).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1026), 96, 1128);
- Table.States (1026).Kernel := To_Vector ((0 => (305, 220, 1,
False)));
- Table.States (1026).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1128)));
- Table.States (1027).Action_List.Set_Capacity (4);
- Add_Action (Table.States (1027), 7, Reduce, (241, 0), 2, null,
null);
- Add_Action (Table.States (1027), 104, 1129);
- Add_Action (Table.States (1027), 105, 33);
- Add_Action (Table.States (1027), 106, 34);
- Table.States (1027).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (1027), 128, 41);
- Add_Goto (Table.States (1027), 239, 872);
- Add_Goto (Table.States (1027), 272, 92);
- Add_Goto (Table.States (1027), 293, 1130);
- Table.States (1027).Kernel := To_Vector (((241, 41, 0, False),
(242, 41, 1, False), (242, 41, 3, False)));
- Table.States (1027).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 241, 2)));
- Table.States (1028).Action_List.Set_Capacity (14);
- Add_Action (Table.States (1028), 3, 121);
- Add_Action (Table.States (1028), 39, 122);
- Add_Action (Table.States (1028), 40, 123);
- Add_Action (Table.States (1028), 41, 124);
- Add_Action (Table.States (1028), 52, 125);
- Add_Action (Table.States (1028), 76, 126);
- Add_Action (Table.States (1028), 77, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (1028), 94, 127);
- Add_Action (Table.States (1028), 95, 128);
- Add_Action (Table.States (1028), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (1028), 103, 129);
- Add_Action (Table.States (1028), 104, 119);
- Add_Action (Table.States (1028), 105, 33);
- Add_Action (Table.States (1028), 106, 34);
- Table.States (1028).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (1028), 117, 130);
- Add_Goto (Table.States (1028), 128, 41);
- Add_Goto (Table.States (1028), 191, 131);
- Add_Goto (Table.States (1028), 192, 1131);
- Add_Goto (Table.States (1028), 197, 133);
- Add_Goto (Table.States (1028), 239, 134);
- Add_Goto (Table.States (1028), 258, 135);
- Add_Goto (Table.States (1028), 272, 92);
- Add_Goto (Table.States (1028), 275, 136);
- Add_Goto (Table.States (1028), 282, 137);
- Add_Goto (Table.States (1028), 283, 138);
- Add_Goto (Table.States (1028), 284, 139);
- Add_Goto (Table.States (1028), 285, 140);
- Add_Goto (Table.States (1028), 286, 141);
- Add_Goto (Table.States (1028), 287, 142);
- Add_Goto (Table.States (1028), 293, 97);
- Add_Goto (Table.States (1028), 301, 143);
- Add_Goto (Table.States (1028), 320, 144);
- Add_Goto (Table.States (1028), 321, 145);
- Add_Goto (Table.States (1028), 330, 146);
- Table.States (1028).Kernel := To_Vector ((0 => (170, 82, 0,
False)));
- Table.States (1028).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (1029).Action_List.Set_Capacity (14);
- Add_Action (Table.States (1029), 3, 121);
- Add_Action (Table.States (1029), 39, 122);
- Add_Action (Table.States (1029), 40, 123);
- Add_Action (Table.States (1029), 41, 124);
- Add_Action (Table.States (1029), 52, 125);
- Add_Action (Table.States (1029), 76, 126);
- Add_Action (Table.States (1029), 77, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (1029), 94, 127);
- Add_Action (Table.States (1029), 95, 128);
- Add_Action (Table.States (1029), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (1029), 103, 129);
- Add_Action (Table.States (1029), 104, 119);
- Add_Action (Table.States (1029), 105, 33);
- Add_Action (Table.States (1029), 106, 34);
- Table.States (1029).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (1029), 117, 130);
- Add_Goto (Table.States (1029), 128, 41);
- Add_Goto (Table.States (1029), 191, 131);
- Add_Goto (Table.States (1029), 192, 1132);
- Add_Goto (Table.States (1029), 197, 133);
- Add_Goto (Table.States (1029), 239, 134);
- Add_Goto (Table.States (1029), 258, 135);
- Add_Goto (Table.States (1029), 272, 92);
- Add_Goto (Table.States (1029), 275, 136);
- Add_Goto (Table.States (1029), 282, 137);
- Add_Goto (Table.States (1029), 283, 138);
- Add_Goto (Table.States (1029), 284, 139);
- Add_Goto (Table.States (1029), 285, 140);
- Add_Goto (Table.States (1029), 286, 141);
- Add_Goto (Table.States (1029), 287, 142);
- Add_Goto (Table.States (1029), 293, 97);
- Add_Goto (Table.States (1029), 301, 143);
- Add_Goto (Table.States (1029), 320, 144);
- Add_Goto (Table.States (1029), 321, 145);
- Add_Goto (Table.States (1029), 330, 146);
- Table.States (1029).Kernel := To_Vector ((0 => (170, 82, 0,
False)));
- Table.States (1029).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (1030).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1030), (41, 49, 54), (111, 0), 3, null,
null);
- Table.States (1030).Kernel := To_Vector ((0 => (111, 36, 0,
False)));
- Table.States (1030).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 111, 3)));
- Table.States (1031).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1031), 77, 1133);
- Add_Action (Table.States (1031), 83, 959);
- Table.States (1031).Kernel := To_Vector (((120, 168, 3, False),
(168, 168, 2, True)));
- Table.States (1031).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 1133)));
- Table.States (1032).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1032), (77, 83), (226, 1), 1, null,
null);
- Table.States (1032).Kernel := To_Vector ((0 => (226, 225, 0,
False)));
- Table.States (1032).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 226, 1)));
- Table.States (1033).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1033), 77, 1134);
- Add_Action (Table.States (1033), 83, 1135);
- Table.States (1033).Kernel := To_Vector (((120, 226, 3, False),
(226, 226, 4, True)));
- Table.States (1033).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 1134)));
- Table.States (1034).Action_List.Set_Capacity (16);
- Add_Action (Table.States (1034), 38, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (1034), 53, 1136);
- Add_Action (Table.States (1034), 55, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (1034), 76, 621);
- Add_Action (Table.States (1034), 77, Reduce, (314, 3), 1,
subtype_indication_3'Access, null);
- Add_Action (Table.States (1034), 78, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (1034), 83, Reduce, (314, 3), 1,
subtype_indication_3'Access, null);
- Add_Action (Table.States (1034), 84, 237);
- Add_Action (Table.States (1034), 85, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (1034), 94, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (1034), 95, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (1034), 97, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (1034), 99, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (1034), 100, Reduce, (258, 3), 1, null,
null);
- Add_Action (Table.States (1034), 101, 239);
- Add_Action (Table.States (1034), 102, 240);
- Table.States (1034).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (1034), 115, 241);
- Add_Goto (Table.States (1034), 155, 622);
- Add_Goto (Table.States (1034), 224, 623);
- Add_Goto (Table.States (1034), 322, 448);
- Table.States (1034).Kernel := To_Vector (((128, 239, 2, True),
(225, 239, 2, False), (239, 239, 5, True),
- (239, 239, 2, True), (258, 239, 0, False), (272, 239, 3, True),
(277, 239, 4, False), (277, 239, 2, False),
- (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True), (314, 239, 4, False),
- (314, 239, 0, False)));
- Table.States (1034).Minimal_Complete_Actions := To_Vector
(((Reduce, 258, 1), (Reduce, 314, 1)));
- Table.States (1035).Action_List.Set_Capacity (15);
- Add_Action (Table.States (1035), 3, 121);
- Add_Action (Table.States (1035), 39, 122);
- Add_Action (Table.States (1035), 40, 123);
- Add_Action (Table.States (1035), 41, 124);
- Add_Action (Table.States (1035), 52, 125);
- Add_Action (Table.States (1035), 53, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (1035), 74, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (1035), 76, 126);
- Add_Action (Table.States (1035), 94, 127);
- Add_Action (Table.States (1035), 95, 128);
- Add_Action (Table.States (1035), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (1035), 103, 129);
- Add_Action (Table.States (1035), 104, 119);
- Add_Action (Table.States (1035), 105, 33);
- Add_Action (Table.States (1035), 106, 34);
- Table.States (1035).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (1035), 117, 130);
- Add_Goto (Table.States (1035), 128, 41);
- Add_Goto (Table.States (1035), 191, 131);
- Add_Goto (Table.States (1035), 192, 1137);
- Add_Goto (Table.States (1035), 197, 133);
- Add_Goto (Table.States (1035), 239, 134);
- Add_Goto (Table.States (1035), 258, 135);
- Add_Goto (Table.States (1035), 272, 92);
- Add_Goto (Table.States (1035), 275, 136);
- Add_Goto (Table.States (1035), 282, 137);
- Add_Goto (Table.States (1035), 283, 138);
- Add_Goto (Table.States (1035), 284, 139);
- Add_Goto (Table.States (1035), 285, 140);
- Add_Goto (Table.States (1035), 286, 141);
- Add_Goto (Table.States (1035), 287, 142);
- Add_Goto (Table.States (1035), 293, 97);
- Add_Goto (Table.States (1035), 301, 143);
- Add_Goto (Table.States (1035), 320, 144);
- Add_Goto (Table.States (1035), 321, 145);
- Add_Goto (Table.States (1035), 330, 146);
- Table.States (1035).Kernel := To_Vector ((0 => (326, 20, 0,
False)));
- Table.States (1035).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (1036).Action_List.Set_Capacity (11);
- Add_Action (Table.States (1036), 3, 121);
- Add_Action (Table.States (1036), 39, 122);
- Add_Action (Table.States (1036), 40, 123);
- Add_Action (Table.States (1036), 41, 124);
- Add_Action (Table.States (1036), 76, 126);
- Add_Action (Table.States (1036), 94, 127);
- Add_Action (Table.States (1036), 95, 128);
- Add_Action (Table.States (1036), 103, 129);
- Add_Action (Table.States (1036), 104, 119);
- Add_Action (Table.States (1036), 105, 33);
- Add_Action (Table.States (1036), 106, 34);
- Table.States (1036).Goto_List.Set_Capacity (11);
- Add_Goto (Table.States (1036), 117, 130);
- Add_Goto (Table.States (1036), 128, 41);
- Add_Goto (Table.States (1036), 197, 133);
- Add_Goto (Table.States (1036), 239, 134);
- Add_Goto (Table.States (1036), 258, 135);
- Add_Goto (Table.States (1036), 272, 92);
- Add_Goto (Table.States (1036), 293, 97);
- Add_Goto (Table.States (1036), 301, 1138);
- Add_Goto (Table.States (1036), 320, 144);
- Add_Goto (Table.States (1036), 321, 145);
- Add_Goto (Table.States (1036), 330, 146);
- Table.States (1036).Kernel := To_Vector ((0 => (279, 53, 3,
False)));
- Table.States (1036).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
- Table.States (1037).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1037), (74, 96), (326, 5), 3, null,
null);
- Table.States (1037).Kernel := To_Vector ((0 => (326, 279, 0,
False)));
- Table.States (1037).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 326, 3)));
- Table.States (1038).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1038), (74, 96), (326, 3), 3, null,
null);
- Table.States (1038).Kernel := To_Vector ((0 => (326, 279, 0,
False)));
- Table.States (1038).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 326, 3)));
- Table.States (1039).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1039), 104, 119);
- Add_Action (Table.States (1039), 105, 33);
+ Add_Action (Table.States (1025), 35, 591);
+ Table.States (1025).Kernel := To_Vector ((0 => (308, 123, 4,
False)));
+ Table.States (1025).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 591)));
+ Table.States (1026).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (1026), (4, 5, 13, 15, 17, 18, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (153, 0), 7, conditional_entry_call_0'Access, null);
+ Table.States (1026).Kernel := To_Vector ((0 => (153, 97, 0,
False)));
+ Table.States (1026).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 153, 7)));
+ Table.States (1027).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (1027), (4, 5, 13, 15, 17, 18, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (324, 0), 7, timed_entry_call_0'Access, null);
+ Table.States (1027).Kernel := To_Vector ((0 => (324, 97, 0,
False)));
+ Table.States (1027).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 324, 7)));
+ Table.States (1028).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (1028), (4, 5, 13, 15, 17, 18, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (295, 0), 7, selective_accept_0'Access, null);
+ Table.States (1028).Kernel := To_Vector ((0 => (295, 97, 0,
False)));
+ Table.States (1028).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 295, 7)));
+ Table.States (1029).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1029), 97, 1134);
+ Table.States (1029).Kernel := To_Vector ((0 => (127, 61, 1,
False)));
+ Table.States (1029).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1134)));
+ Table.States (1030).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1030), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (318, 0), 7,
+ task_body_stub_0'Access, null);
+ Table.States (1030).Kernel := To_Vector ((0 => (318, 97, 0,
False)));
+ Table.States (1030).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 318, 7)));
+ Table.States (1031).Action_List.Set_Capacity (25);
+ Add_Action (Table.States (1031), 4, 1);
+ Add_Action (Table.States (1031), 5, 2);
+ Add_Action (Table.States (1031), 13, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (1031), 15, 3);
+ Add_Action (Table.States (1031), 17, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (1031), 18, 4);
+ Add_Action (Table.States (1031), 24, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (1031), 26, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (1031), 27, 5);
+ Add_Action (Table.States (1031), 28, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (1031), 31, 9);
+ Add_Action (Table.States (1031), 32, 10);
+ Add_Action (Table.States (1031), 37, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (1031), 41, 13);
+ Add_Action (Table.States (1031), 48, 16);
+ Add_Action (Table.States (1031), 52, 20);
+ Add_Action (Table.States (1031), 57, 21);
+ Add_Action (Table.States (1031), 58, 22);
+ Add_Action (Table.States (1031), 61, 24);
+ Add_Action (Table.States (1031), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (1031), 79, 31);
+ Add_Action (Table.States (1031), 94, 32);
+ Add_Action (Table.States (1031), 105, 361);
+ Add_Action (Table.States (1031), 106, 34);
+ Add_Action (Table.States (1031), 107, 35);
+ Table.States (1031).Goto_List.Set_Capacity (32);
+ Add_Goto (Table.States (1031), 114, 37);
+ Add_Goto (Table.States (1031), 124, 39);
+ Add_Goto (Table.States (1031), 127, 40);
+ Add_Goto (Table.States (1031), 129, 42);
+ Add_Goto (Table.States (1031), 132, 43);
+ Add_Goto (Table.States (1031), 133, 44);
+ Add_Goto (Table.States (1031), 134, 45);
+ Add_Goto (Table.States (1031), 140, 48);
+ Add_Goto (Table.States (1031), 152, 51);
+ Add_Goto (Table.States (1031), 153, 52);
+ Add_Goto (Table.States (1031), 162, 54);
+ Add_Goto (Table.States (1031), 191, 58);
+ Add_Goto (Table.States (1031), 197, 60);
+ Add_Goto (Table.States (1031), 218, 69);
+ Add_Goto (Table.States (1031), 219, 1135);
+ Add_Goto (Table.States (1031), 223, 71);
+ Add_Goto (Table.States (1031), 233, 73);
+ Add_Goto (Table.States (1031), 240, 74);
+ Add_Goto (Table.States (1031), 258, 84);
+ Add_Goto (Table.States (1031), 262, 87);
+ Add_Goto (Table.States (1031), 273, 93);
+ Add_Goto (Table.States (1031), 277, 94);
+ Add_Goto (Table.States (1031), 291, 97);
+ Add_Goto (Table.States (1031), 294, 98);
+ Add_Goto (Table.States (1031), 295, 99);
+ Add_Goto (Table.States (1031), 299, 100);
+ Add_Goto (Table.States (1031), 300, 362);
+ Add_Goto (Table.States (1031), 301, 391);
+ Add_Goto (Table.States (1031), 303, 101);
+ Add_Goto (Table.States (1031), 304, 102);
+ Add_Goto (Table.States (1031), 307, 364);
+ Add_Goto (Table.States (1031), 324, 115);
+ Table.States (1031).Kernel := To_Vector ((0 => (317, 13, 2,
False)));
+ Table.States (1031).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 219, 0)));
+ Table.States (1032).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (1032), 79, 31);
+ Add_Action (Table.States (1032), 105, 120);
+ Add_Action (Table.States (1032), 106, 34);
+ Add_Action (Table.States (1032), 107, 35);
+ Table.States (1032).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (1032), 129, 42);
+ Add_Goto (Table.States (1032), 228, 1136);
+ Add_Goto (Table.States (1032), 240, 850);
+ Add_Goto (Table.States (1032), 273, 93);
+ Add_Goto (Table.States (1032), 294, 98);
+ Table.States (1032).Kernel := To_Vector ((0 => (320, 39, 4,
False)));
+ Table.States (1032).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (1033).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1033), 24, 1137);
+ Table.States (1033).Kernel := To_Vector ((0 => (320, 319, 2,
False)));
+ Table.States (1033).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1137)));
+ Table.States (1034).Action_List.Set_Capacity (17);
+ Add_Action (Table.States (1034), 24, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (1034), 25, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (1034), 28, 184);
+ Add_Action (Table.States (1034), 29, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (1034), 30, 8);
+ Add_Action (Table.States (1034), 40, 12);
+ Add_Action (Table.States (1034), 46, 14);
+ Add_Action (Table.States (1034), 47, 15);
+ Add_Action (Table.States (1034), 48, 16);
+ Add_Action (Table.States (1034), 49, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (1034), 50, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (1034), 51, 19);
+ Add_Action (Table.States (1034), 63, 25);
+ Add_Action (Table.States (1034), 66, 26);
+ Add_Action (Table.States (1034), 69, 27);
+ Add_Action (Table.States (1034), 71, 28);
+ Add_Action (Table.States (1034), 105, 186);
+ Table.States (1034).Goto_List.Set_Capacity (54);
+ Add_Goto (Table.States (1034), 113, 36);
+ Add_Goto (Table.States (1034), 122, 38);
+ Add_Goto (Table.States (1034), 128, 41);
+ Add_Goto (Table.States (1034), 135, 46);
+ Add_Goto (Table.States (1034), 136, 47);
+ Add_Goto (Table.States (1034), 158, 392);
+ Add_Goto (Table.States (1034), 159, 393);
+ Add_Goto (Table.States (1034), 160, 700);
+ Add_Goto (Table.States (1034), 180, 55);
+ Add_Goto (Table.States (1034), 183, 56);
+ Add_Goto (Table.States (1034), 187, 57);
+ Add_Goto (Table.States (1034), 194, 59);
+ Add_Goto (Table.States (1034), 207, 61);
+ Add_Goto (Table.States (1034), 208, 62);
+ Add_Goto (Table.States (1034), 210, 63);
+ Add_Goto (Table.States (1034), 211, 64);
+ Add_Goto (Table.States (1034), 214, 65);
+ Add_Goto (Table.States (1034), 215, 66);
+ Add_Goto (Table.States (1034), 216, 67);
+ Add_Goto (Table.States (1034), 217, 68);
+ Add_Goto (Table.States (1034), 220, 70);
+ Add_Goto (Table.States (1034), 224, 72);
+ Add_Goto (Table.States (1034), 244, 75);
+ Add_Goto (Table.States (1034), 245, 76);
+ Add_Goto (Table.States (1034), 246, 77);
+ Add_Goto (Table.States (1034), 247, 78);
+ Add_Goto (Table.States (1034), 248, 79);
+ Add_Goto (Table.States (1034), 249, 80);
+ Add_Goto (Table.States (1034), 250, 81);
+ Add_Goto (Table.States (1034), 251, 82);
+ Add_Goto (Table.States (1034), 252, 83);
+ Add_Goto (Table.States (1034), 258, 395);
+ Add_Goto (Table.States (1034), 260, 85);
+ Add_Goto (Table.States (1034), 261, 86);
+ Add_Goto (Table.States (1034), 263, 88);
+ Add_Goto (Table.States (1034), 264, 89);
+ Add_Goto (Table.States (1034), 265, 90);
+ Add_Goto (Table.States (1034), 266, 91);
+ Add_Goto (Table.States (1034), 272, 92);
+ Add_Goto (Table.States (1034), 282, 95);
+ Add_Goto (Table.States (1034), 290, 96);
+ Add_Goto (Table.States (1034), 305, 103);
+ Add_Goto (Table.States (1034), 306, 104);
+ Add_Goto (Table.States (1034), 308, 106);
+ Add_Goto (Table.States (1034), 309, 107);
+ Add_Goto (Table.States (1034), 310, 108);
+ Add_Goto (Table.States (1034), 312, 109);
+ Add_Goto (Table.States (1034), 314, 110);
+ Add_Goto (Table.States (1034), 317, 112);
+ Add_Goto (Table.States (1034), 318, 113);
+ Add_Goto (Table.States (1034), 319, 1138);
+ Add_Goto (Table.States (1034), 320, 114);
+ Add_Goto (Table.States (1034), 326, 116);
+ Add_Goto (Table.States (1034), 332, 117);
+ Table.States (1034).Kernel := To_Vector ((0 => (306, 74, 2,
False)));
+ Table.States (1034).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 319, 0)));
+ Table.States (1035).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1035), (1 => 24), (319, 0), 3,
task_definition_0'Access, null);
+ Table.States (1035).Kernel := To_Vector ((0 => (319, 160, 0,
False)));
+ Table.States (1035).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 319, 3)));
+ Table.States (1036).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1036), 97, 1139);
+ Table.States (1036).Kernel := To_Vector ((0 => (306, 221, 1,
False)));
+ Table.States (1036).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1139)));
+ Table.States (1037).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (1037), 7, Reduce, (242, 0), 2, null,
null);
+ Add_Action (Table.States (1037), 79, 31);
+ Add_Action (Table.States (1037), 105, 1140);
+ Add_Action (Table.States (1037), 106, 34);
+ Add_Action (Table.States (1037), 107, 35);
+ Table.States (1037).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (1037), 129, 42);
+ Add_Goto (Table.States (1037), 240, 880);
+ Add_Goto (Table.States (1037), 273, 93);
+ Add_Goto (Table.States (1037), 294, 1141);
+ Table.States (1037).Kernel := To_Vector (((242, 41, 0, False),
(243, 41, 1, False), (243, 41, 3, False)));
+ Table.States (1037).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 242, 2)));
+ Table.States (1038).Action_List.Set_Capacity (15);
+ Add_Action (Table.States (1038), 3, 122);
+ Add_Action (Table.States (1038), 39, 123);
+ Add_Action (Table.States (1038), 40, 124);
+ Add_Action (Table.States (1038), 41, 125);
+ Add_Action (Table.States (1038), 52, 126);
+ Add_Action (Table.States (1038), 76, 127);
+ Add_Action (Table.States (1038), 77, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (1038), 79, 31);
+ Add_Action (Table.States (1038), 95, 128);
+ Add_Action (Table.States (1038), 96, 129);
+ Add_Action (Table.States (1038), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (1038), 104, 130);
+ Add_Action (Table.States (1038), 105, 120);
+ Add_Action (Table.States (1038), 106, 34);
+ Add_Action (Table.States (1038), 107, 35);
+ Table.States (1038).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (1038), 118, 131);
+ Add_Goto (Table.States (1038), 129, 42);
+ Add_Goto (Table.States (1038), 192, 132);
+ Add_Goto (Table.States (1038), 193, 1142);
+ Add_Goto (Table.States (1038), 198, 134);
+ Add_Goto (Table.States (1038), 240, 135);
+ Add_Goto (Table.States (1038), 259, 136);
+ Add_Goto (Table.States (1038), 273, 93);
+ Add_Goto (Table.States (1038), 276, 137);
+ Add_Goto (Table.States (1038), 283, 138);
+ Add_Goto (Table.States (1038), 284, 139);
+ Add_Goto (Table.States (1038), 285, 140);
+ Add_Goto (Table.States (1038), 286, 141);
+ Add_Goto (Table.States (1038), 287, 142);
+ Add_Goto (Table.States (1038), 288, 143);
+ Add_Goto (Table.States (1038), 294, 98);
+ Add_Goto (Table.States (1038), 302, 144);
+ Add_Goto (Table.States (1038), 321, 145);
+ Add_Goto (Table.States (1038), 322, 146);
+ Add_Goto (Table.States (1038), 331, 147);
+ Table.States (1038).Kernel := To_Vector ((0 => (171, 83, 0,
False)));
+ Table.States (1038).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (1039).Action_List.Set_Capacity (15);
+ Add_Action (Table.States (1039), 3, 122);
+ Add_Action (Table.States (1039), 39, 123);
+ Add_Action (Table.States (1039), 40, 124);
+ Add_Action (Table.States (1039), 41, 125);
+ Add_Action (Table.States (1039), 52, 126);
+ Add_Action (Table.States (1039), 76, 127);
+ Add_Action (Table.States (1039), 77, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (1039), 79, 31);
+ Add_Action (Table.States (1039), 95, 128);
+ Add_Action (Table.States (1039), 96, 129);
+ Add_Action (Table.States (1039), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (1039), 104, 130);
+ Add_Action (Table.States (1039), 105, 120);
Add_Action (Table.States (1039), 106, 34);
- Table.States (1039).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (1039), 128, 41);
- Add_Goto (Table.States (1039), 227, 1139);
- Add_Goto (Table.States (1039), 239, 842);
- Add_Goto (Table.States (1039), 272, 92);
- Add_Goto (Table.States (1039), 293, 97);
- Table.States (1039).Kernel := To_Vector ((0 => (228, 10, 1,
False)));
- Table.States (1039).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
+ Add_Action (Table.States (1039), 107, 35);
+ Table.States (1039).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (1039), 118, 131);
+ Add_Goto (Table.States (1039), 129, 42);
+ Add_Goto (Table.States (1039), 192, 132);
+ Add_Goto (Table.States (1039), 193, 1143);
+ Add_Goto (Table.States (1039), 198, 134);
+ Add_Goto (Table.States (1039), 240, 135);
+ Add_Goto (Table.States (1039), 259, 136);
+ Add_Goto (Table.States (1039), 273, 93);
+ Add_Goto (Table.States (1039), 276, 137);
+ Add_Goto (Table.States (1039), 283, 138);
+ Add_Goto (Table.States (1039), 284, 139);
+ Add_Goto (Table.States (1039), 285, 140);
+ Add_Goto (Table.States (1039), 286, 141);
+ Add_Goto (Table.States (1039), 287, 142);
+ Add_Goto (Table.States (1039), 288, 143);
+ Add_Goto (Table.States (1039), 294, 98);
+ Add_Goto (Table.States (1039), 302, 144);
+ Add_Goto (Table.States (1039), 321, 145);
+ Add_Goto (Table.States (1039), 322, 146);
+ Add_Goto (Table.States (1039), 331, 147);
+ Table.States (1039).Kernel := To_Vector ((0 => (171, 83, 0,
False)));
+ Table.States (1039).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
Table.States (1040).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1040), 104, 119);
- Add_Action (Table.States (1040), 105, 33);
- Add_Action (Table.States (1040), 106, 34);
- Table.States (1040).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (1040), 128, 41);
- Add_Goto (Table.States (1040), 227, 1140);
- Add_Goto (Table.States (1040), 239, 842);
- Add_Goto (Table.States (1040), 272, 92);
- Add_Goto (Table.States (1040), 293, 97);
- Table.States (1040).Kernel := To_Vector ((0 => (228, 10, 1,
False)));
- Table.States (1040).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (1041).Action_List.Set_Capacity (11);
- Add_Action (Table.States (1041), 3, 121);
- Add_Action (Table.States (1041), 39, 122);
- Add_Action (Table.States (1041), 40, 123);
- Add_Action (Table.States (1041), 41, 124);
- Add_Action (Table.States (1041), 76, 126);
- Add_Action (Table.States (1041), 94, 127);
- Add_Action (Table.States (1041), 95, 128);
- Add_Action (Table.States (1041), 103, 129);
- Add_Action (Table.States (1041), 104, 119);
- Add_Action (Table.States (1041), 105, 33);
- Add_Action (Table.States (1041), 106, 34);
- Table.States (1041).Goto_List.Set_Capacity (11);
- Add_Goto (Table.States (1041), 117, 130);
- Add_Goto (Table.States (1041), 128, 41);
- Add_Goto (Table.States (1041), 197, 133);
- Add_Goto (Table.States (1041), 239, 134);
- Add_Goto (Table.States (1041), 258, 135);
- Add_Goto (Table.States (1041), 272, 92);
- Add_Goto (Table.States (1041), 293, 97);
- Add_Goto (Table.States (1041), 301, 1141);
- Add_Goto (Table.States (1041), 320, 144);
- Add_Goto (Table.States (1041), 321, 145);
- Add_Goto (Table.States (1041), 330, 146);
- Table.States (1041).Kernel := To_Vector ((0 => (326, 85, 1,
False)));
- Table.States (1041).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
- Table.States (1042).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1042), (1 => 35), (163, 0), 1, null,
null);
- Table.States (1042).Kernel := To_Vector ((0 => (163, 104, 0,
False)));
- Table.States (1042).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 163, 1)));
- Table.States (1043).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1043), (1 => 35), (163, 1), 1, null,
null);
- Table.States (1043).Kernel := To_Vector ((0 => (163, 105, 0,
False)));
- Table.States (1043).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 163, 1)));
- Table.States (1044).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1044), (1 => 35), (164, 0), 1, null,
null);
- Table.States (1044).Kernel := To_Vector ((0 => (164, 163, 0,
False)));
- Table.States (1044).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 164, 1)));
- Table.States (1045).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1045), 35, 1142);
- Table.States (1045).Kernel := To_Vector ((0 => (327, 164, 6,
False)));
- Table.States (1045).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 1142)));
- Table.States (1046).Action_List.Set_Capacity (5);
- Add_Action (Table.States (1046), (15, 24, 28, 72, 104), (149, 4),
2, component_list_4'Access, null);
- Table.States (1046).Kernel := To_Vector ((0 => (149, 96, 0,
False)));
- Table.States (1046).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 149, 2)));
- Table.States (1047).Action_List.Set_Capacity (5);
- Add_Action (Table.States (1047), (15, 24, 28, 72, 104), (149, 0),
2, null, null);
- Table.States (1047).Kernel := To_Vector ((0 => (149, 148, 0,
True)));
- Table.States (1047).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 149, 2)));
- Table.States (1047).Minimal_Complete_Actions_Recursive := True;
- Table.States (1048).Action_List.Set_Capacity (5);
- Add_Action (Table.States (1048), (15, 24, 28, 72, 104), (149, 1),
2, null, null);
- Table.States (1048).Kernel := To_Vector ((0 => (149, 327, 0,
True)));
- Table.States (1048).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 149, 2)));
- Table.States (1048).Minimal_Complete_Actions_Recursive := True;
- Table.States (1049).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1049), 54, 1143);
- Table.States (1049).Kernel := To_Vector ((0 => (280, 24, 1,
False)));
- Table.States (1049).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 54, 1143)));
- Table.States (1050).Action_List.Set_Capacity (6);
- Add_Action (Table.States (1050), 7, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (1050), 8, 1144);
- Add_Action (Table.States (1050), 40, 744);
- Add_Action (Table.States (1050), 104, 119);
- Add_Action (Table.States (1050), 105, 33);
+ Add_Action (Table.States (1040), (41, 49, 54), (112, 0), 3, null,
null);
+ Table.States (1040).Kernel := To_Vector ((0 => (112, 36, 0,
False)));
+ Table.States (1040).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 112, 3)));
+ Table.States (1041).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1041), 77, 1144);
+ Add_Action (Table.States (1041), 84, 969);
+ Table.States (1041).Kernel := To_Vector (((121, 169, 3, False),
(169, 169, 2, True)));
+ Table.States (1041).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 1144)));
+ Table.States (1042).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1042), (77, 84), (227, 1), 1, null,
null);
+ Table.States (1042).Kernel := To_Vector ((0 => (227, 226, 0,
False)));
+ Table.States (1042).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 227, 1)));
+ Table.States (1043).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1043), 77, 1145);
+ Add_Action (Table.States (1043), 84, 1146);
+ Table.States (1043).Kernel := To_Vector (((121, 227, 3, False),
(227, 227, 4, True)));
+ Table.States (1043).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 1145)));
+ Table.States (1044).Action_List.Set_Capacity (16);
+ Add_Action (Table.States (1044), 38, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (1044), 53, 1147);
+ Add_Action (Table.States (1044), 55, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (1044), 76, 627);
+ Add_Action (Table.States (1044), 77, Reduce, (315, 3), 1,
subtype_indication_3'Access, null);
+ Add_Action (Table.States (1044), 78, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (1044), 84, Reduce, (315, 3), 1,
subtype_indication_3'Access, null);
+ Add_Action (Table.States (1044), 85, 238);
+ Add_Action (Table.States (1044), 86, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (1044), 95, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (1044), 96, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (1044), 98, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (1044), 100, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (1044), 101, Reduce, (259, 3), 1, null,
null);
+ Add_Action (Table.States (1044), 102, 240);
+ Add_Action (Table.States (1044), 103, 241);
+ Table.States (1044).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (1044), 116, 242);
+ Add_Goto (Table.States (1044), 156, 628);
+ Add_Goto (Table.States (1044), 225, 629);
+ Add_Goto (Table.States (1044), 323, 451);
+ Table.States (1044).Kernel := To_Vector (((129, 240, 2, True),
(226, 240, 2, False), (240, 240, 5, True),
+ (240, 240, 2, True), (259, 240, 0, False), (273, 240, 3, True),
(278, 240, 4, False), (278, 240, 2, False),
+ (294, 240, 2, True), (294, 240, 2, True), (294, 240, 2, True),
(294, 240, 2, True), (315, 240, 4, False),
+ (315, 240, 0, False)));
+ Table.States (1044).Minimal_Complete_Actions := To_Vector
(((Reduce, 259, 1), (Reduce, 315, 1)));
+ Table.States (1045).Action_List.Set_Capacity (16);
+ Add_Action (Table.States (1045), 3, 122);
+ Add_Action (Table.States (1045), 39, 123);
+ Add_Action (Table.States (1045), 40, 124);
+ Add_Action (Table.States (1045), 41, 125);
+ Add_Action (Table.States (1045), 52, 126);
+ Add_Action (Table.States (1045), 53, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (1045), 74, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (1045), 76, 127);
+ Add_Action (Table.States (1045), 79, 31);
+ Add_Action (Table.States (1045), 95, 128);
+ Add_Action (Table.States (1045), 96, 129);
+ Add_Action (Table.States (1045), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (1045), 104, 130);
+ Add_Action (Table.States (1045), 105, 120);
+ Add_Action (Table.States (1045), 106, 34);
+ Add_Action (Table.States (1045), 107, 35);
+ Table.States (1045).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (1045), 118, 131);
+ Add_Goto (Table.States (1045), 129, 42);
+ Add_Goto (Table.States (1045), 192, 132);
+ Add_Goto (Table.States (1045), 193, 1148);
+ Add_Goto (Table.States (1045), 198, 134);
+ Add_Goto (Table.States (1045), 240, 135);
+ Add_Goto (Table.States (1045), 259, 136);
+ Add_Goto (Table.States (1045), 273, 93);
+ Add_Goto (Table.States (1045), 276, 137);
+ Add_Goto (Table.States (1045), 283, 138);
+ Add_Goto (Table.States (1045), 284, 139);
+ Add_Goto (Table.States (1045), 285, 140);
+ Add_Goto (Table.States (1045), 286, 141);
+ Add_Goto (Table.States (1045), 287, 142);
+ Add_Goto (Table.States (1045), 288, 143);
+ Add_Goto (Table.States (1045), 294, 98);
+ Add_Goto (Table.States (1045), 302, 144);
+ Add_Goto (Table.States (1045), 321, 145);
+ Add_Goto (Table.States (1045), 322, 146);
+ Add_Goto (Table.States (1045), 331, 147);
+ Table.States (1045).Kernel := To_Vector ((0 => (327, 20, 0,
False)));
+ Table.States (1045).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (1046).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (1046), 3, 122);
+ Add_Action (Table.States (1046), 39, 123);
+ Add_Action (Table.States (1046), 40, 124);
+ Add_Action (Table.States (1046), 41, 125);
+ Add_Action (Table.States (1046), 76, 127);
+ Add_Action (Table.States (1046), 79, 31);
+ Add_Action (Table.States (1046), 95, 128);
+ Add_Action (Table.States (1046), 96, 129);
+ Add_Action (Table.States (1046), 104, 130);
+ Add_Action (Table.States (1046), 105, 120);
+ Add_Action (Table.States (1046), 106, 34);
+ Add_Action (Table.States (1046), 107, 35);
+ Table.States (1046).Goto_List.Set_Capacity (11);
+ Add_Goto (Table.States (1046), 118, 131);
+ Add_Goto (Table.States (1046), 129, 42);
+ Add_Goto (Table.States (1046), 198, 134);
+ Add_Goto (Table.States (1046), 240, 135);
+ Add_Goto (Table.States (1046), 259, 136);
+ Add_Goto (Table.States (1046), 273, 93);
+ Add_Goto (Table.States (1046), 294, 98);
+ Add_Goto (Table.States (1046), 302, 1149);
+ Add_Goto (Table.States (1046), 321, 145);
+ Add_Goto (Table.States (1046), 322, 146);
+ Add_Goto (Table.States (1046), 331, 147);
+ Table.States (1046).Kernel := To_Vector ((0 => (280, 53, 3,
False)));
+ Table.States (1046).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
+ Table.States (1047).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1047), (74, 97), (327, 5), 3, null,
null);
+ Table.States (1047).Kernel := To_Vector ((0 => (327, 280, 0,
False)));
+ Table.States (1047).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 327, 3)));
+ Table.States (1048).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1048), (74, 97), (327, 3), 3, null,
null);
+ Table.States (1048).Kernel := To_Vector ((0 => (327, 280, 0,
False)));
+ Table.States (1048).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 327, 3)));
+ Table.States (1049).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (1049), 79, 31);
+ Add_Action (Table.States (1049), 105, 120);
+ Add_Action (Table.States (1049), 106, 34);
+ Add_Action (Table.States (1049), 107, 35);
+ Table.States (1049).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (1049), 129, 42);
+ Add_Goto (Table.States (1049), 228, 1150);
+ Add_Goto (Table.States (1049), 240, 850);
+ Add_Goto (Table.States (1049), 273, 93);
+ Add_Goto (Table.States (1049), 294, 98);
+ Table.States (1049).Kernel := To_Vector ((0 => (229, 10, 1,
False)));
+ Table.States (1049).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (1050).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (1050), 79, 31);
+ Add_Action (Table.States (1050), 105, 120);
Add_Action (Table.States (1050), 106, 34);
- Table.States (1050).Goto_List.Set_Capacity (8);
- Add_Goto (Table.States (1050), 114, 1145);
- Add_Goto (Table.States (1050), 128, 41);
- Add_Goto (Table.States (1050), 147, 1146);
- Add_Goto (Table.States (1050), 239, 484);
- Add_Goto (Table.States (1050), 241, 723);
- Add_Goto (Table.States (1050), 272, 92);
- Add_Goto (Table.States (1050), 293, 97);
- Add_Goto (Table.States (1050), 314, 1147);
- Table.States (1050).Kernel := To_Vector (((146, 81, 3, False),
(146, 81, 2, False)));
- Table.States (1050).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (1051).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1051), 104, 119);
- Add_Action (Table.States (1051), 105, 33);
+ Add_Action (Table.States (1050), 107, 35);
+ Table.States (1050).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (1050), 129, 42);
+ Add_Goto (Table.States (1050), 228, 1151);
+ Add_Goto (Table.States (1050), 240, 850);
+ Add_Goto (Table.States (1050), 273, 93);
+ Add_Goto (Table.States (1050), 294, 98);
+ Table.States (1050).Kernel := To_Vector ((0 => (229, 10, 1,
False)));
+ Table.States (1050).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ end Subr_18;
+ procedure Subr_19
+ is begin
+ Table.States (1051).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (1051), 3, 122);
+ Add_Action (Table.States (1051), 39, 123);
+ Add_Action (Table.States (1051), 40, 124);
+ Add_Action (Table.States (1051), 41, 125);
+ Add_Action (Table.States (1051), 76, 127);
+ Add_Action (Table.States (1051), 79, 31);
+ Add_Action (Table.States (1051), 95, 128);
+ Add_Action (Table.States (1051), 96, 129);
+ Add_Action (Table.States (1051), 104, 130);
+ Add_Action (Table.States (1051), 105, 120);
Add_Action (Table.States (1051), 106, 34);
- Table.States (1051).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (1051), 128, 41);
- Add_Goto (Table.States (1051), 227, 1148);
- Add_Goto (Table.States (1051), 239, 842);
- Add_Goto (Table.States (1051), 272, 92);
- Add_Goto (Table.States (1051), 293, 97);
- Table.States (1051).Kernel := To_Vector ((0 => (228, 10, 1,
False)));
- Table.States (1051).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (1052).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1052), 104, 119);
- Add_Action (Table.States (1052), 105, 33);
- Add_Action (Table.States (1052), 106, 34);
- Table.States (1052).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (1052), 128, 41);
- Add_Goto (Table.States (1052), 227, 1149);
- Add_Goto (Table.States (1052), 239, 842);
- Add_Goto (Table.States (1052), 272, 92);
- Add_Goto (Table.States (1052), 293, 97);
- Table.States (1052).Kernel := To_Vector ((0 => (228, 10, 1,
False)));
- Table.States (1052).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (1053).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1053), (74, 96), (183, 0), 3,
enumeration_type_definition_0'Access, null);
- Table.States (1053).Kernel := To_Vector ((0 => (183, 77, 0,
False)));
- Table.States (1053).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 183, 3)));
- Table.States (1054).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1054), 104, 899);
- Add_Action (Table.States (1054), 106, 900);
- Table.States (1054).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (1054), 180, 1150);
- Table.States (1054).Kernel := To_Vector ((0 => (181, 83, 1,
True)));
- Table.States (1054).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 899)));
- Table.States (1054).Minimal_Complete_Actions_Recursive := True;
- Table.States (1055).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1055), 10, 1151);
- Add_Action (Table.States (1055), 74, Reduce, (119, 1), 0, null,
null);
- Table.States (1055).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (1055), 119, 1152);
- Table.States (1055).Kernel := To_Vector ((0 => (259, 314, 3,
False)));
- Table.States (1055).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 119, 0)));
- Table.States (1056).Action_List.Set_Capacity (8);
- Add_Action (Table.States (1056), 10, 1151);
- Add_Action (Table.States (1056), 53, 620);
- Add_Action (Table.States (1056), 74, Reduce, (119, 1), 0, null,
null);
- Add_Conflict (Table.States (1056), 74, (156, 1), 0, null, null);
- Add_Action (Table.States (1056), 76, 621);
- Add_Action (Table.States (1056), 84, 237);
- Add_Action (Table.States (1056), 96, Reduce, (156, 1), 0, null,
null);
- Add_Action (Table.States (1056), 101, 239);
- Add_Action (Table.States (1056), 102, 240);
- Table.States (1056).Goto_List.Set_Capacity (6);
- Add_Goto (Table.States (1056), 115, 241);
- Add_Goto (Table.States (1056), 119, 1153);
- Add_Goto (Table.States (1056), 155, 1154);
- Add_Goto (Table.States (1056), 156, 1155);
- Add_Goto (Table.States (1056), 224, 623);
- Add_Goto (Table.States (1056), 322, 242);
- Table.States (1056).Kernel := To_Vector (((128, 239, 2, True),
(162, 239, 3, False), (162, 239, 0, False),
- (239, 239, 5, True), (239, 239, 2, True), (272, 239, 3, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True), (293, 239, 2, True)));
- Table.States (1056).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 156, 0)));
- Table.States (1057).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1057), 96, 1156);
- Table.States (1057).Kernel := To_Vector ((0 => (260, 122, 1,
False)));
- Table.States (1057).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1156)));
- Table.States (1058).Action_List.Set_Capacity (40);
- Add_Action (Table.States (1058), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (206, 0), 7,
+ Add_Action (Table.States (1051), 107, 35);
+ Table.States (1051).Goto_List.Set_Capacity (11);
+ Add_Goto (Table.States (1051), 118, 131);
+ Add_Goto (Table.States (1051), 129, 42);
+ Add_Goto (Table.States (1051), 198, 134);
+ Add_Goto (Table.States (1051), 240, 135);
+ Add_Goto (Table.States (1051), 259, 136);
+ Add_Goto (Table.States (1051), 273, 93);
+ Add_Goto (Table.States (1051), 294, 98);
+ Add_Goto (Table.States (1051), 302, 1152);
+ Add_Goto (Table.States (1051), 321, 145);
+ Add_Goto (Table.States (1051), 322, 146);
+ Add_Goto (Table.States (1051), 331, 147);
+ Table.States (1051).Kernel := To_Vector ((0 => (327, 86, 1,
False)));
+ Table.States (1051).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
+ Table.States (1052).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1052), (1 => 35), (164, 0), 1, null,
null);
+ Table.States (1052).Kernel := To_Vector ((0 => (164, 105, 0,
False)));
+ Table.States (1052).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 164, 1)));
+ Table.States (1053).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1053), (1 => 35), (164, 1), 1, null,
null);
+ Table.States (1053).Kernel := To_Vector ((0 => (164, 106, 0,
False)));
+ Table.States (1053).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 164, 1)));
+ Table.States (1054).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1054), (1 => 35), (165, 0), 1, null,
null);
+ Table.States (1054).Kernel := To_Vector ((0 => (165, 164, 0,
False)));
+ Table.States (1054).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 165, 1)));
+ Table.States (1055).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1055), 35, 1153);
+ Table.States (1055).Kernel := To_Vector ((0 => (328, 165, 6,
False)));
+ Table.States (1055).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 1153)));
+ Table.States (1056).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (1056), (15, 24, 28, 72, 105), (150, 4),
2, component_list_4'Access, null);
+ Table.States (1056).Kernel := To_Vector ((0 => (150, 97, 0,
False)));
+ Table.States (1056).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 150, 2)));
+ Table.States (1057).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (1057), (15, 24, 28, 72, 105), (150, 0),
2, null, null);
+ Table.States (1057).Kernel := To_Vector ((0 => (150, 149, 0,
True)));
+ Table.States (1057).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 150, 2)));
+ Table.States (1057).Minimal_Complete_Actions_Recursive := True;
+ Table.States (1058).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (1058), (15, 24, 28, 72, 105), (150, 1),
2, null, null);
+ Table.States (1058).Kernel := To_Vector ((0 => (150, 328, 0,
True)));
+ Table.States (1058).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 150, 2)));
+ Table.States (1058).Minimal_Complete_Actions_Recursive := True;
+ Table.States (1059).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1059), 54, 1154);
+ Table.States (1059).Kernel := To_Vector ((0 => (281, 24, 1,
False)));
+ Table.States (1059).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 54, 1154)));
+ Table.States (1060).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (1060), 7, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (1060), 8, 1155);
+ Add_Action (Table.States (1060), 40, 750);
+ Add_Action (Table.States (1060), 79, 31);
+ Add_Action (Table.States (1060), 105, 120);
+ Add_Action (Table.States (1060), 106, 34);
+ Add_Action (Table.States (1060), 107, 35);
+ Table.States (1060).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (1060), 115, 1156);
+ Add_Goto (Table.States (1060), 129, 42);
+ Add_Goto (Table.States (1060), 148, 1157);
+ Add_Goto (Table.States (1060), 240, 487);
+ Add_Goto (Table.States (1060), 242, 729);
+ Add_Goto (Table.States (1060), 273, 93);
+ Add_Goto (Table.States (1060), 294, 98);
+ Add_Goto (Table.States (1060), 315, 1158);
+ Table.States (1060).Kernel := To_Vector (((147, 82, 3, False),
(147, 82, 2, False)));
+ Table.States (1060).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (1061).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (1061), 79, 31);
+ Add_Action (Table.States (1061), 105, 120);
+ Add_Action (Table.States (1061), 106, 34);
+ Add_Action (Table.States (1061), 107, 35);
+ Table.States (1061).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (1061), 129, 42);
+ Add_Goto (Table.States (1061), 228, 1159);
+ Add_Goto (Table.States (1061), 240, 850);
+ Add_Goto (Table.States (1061), 273, 93);
+ Add_Goto (Table.States (1061), 294, 98);
+ Table.States (1061).Kernel := To_Vector ((0 => (229, 10, 1,
False)));
+ Table.States (1061).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (1062).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (1062), 79, 31);
+ Add_Action (Table.States (1062), 105, 120);
+ Add_Action (Table.States (1062), 106, 34);
+ Add_Action (Table.States (1062), 107, 35);
+ Table.States (1062).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (1062), 129, 42);
+ Add_Goto (Table.States (1062), 228, 1160);
+ Add_Goto (Table.States (1062), 240, 850);
+ Add_Goto (Table.States (1062), 273, 93);
+ Add_Goto (Table.States (1062), 294, 98);
+ Table.States (1062).Kernel := To_Vector ((0 => (229, 10, 1,
False)));
+ Table.States (1062).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (1063).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1063), (74, 97), (184, 0), 3,
enumeration_type_definition_0'Access, null);
+ Table.States (1063).Kernel := To_Vector ((0 => (184, 77, 0,
False)));
+ Table.States (1063).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 184, 3)));
+ Table.States (1064).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1064), 105, 907);
+ Add_Action (Table.States (1064), 107, 908);
+ Table.States (1064).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (1064), 181, 1161);
+ Table.States (1064).Kernel := To_Vector ((0 => (182, 84, 1,
True)));
+ Table.States (1064).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 907)));
+ Table.States (1064).Minimal_Complete_Actions_Recursive := True;
+ Table.States (1065).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1065), 10, 1162);
+ Add_Action (Table.States (1065), 74, Reduce, (120, 1), 0, null,
null);
+ Table.States (1065).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (1065), 120, 1163);
+ Table.States (1065).Kernel := To_Vector ((0 => (260, 315, 3,
False)));
+ Table.States (1065).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 120, 0)));
+ Table.States (1066).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (1066), 10, 1162);
+ Add_Action (Table.States (1066), 53, 626);
+ Add_Action (Table.States (1066), 74, Reduce, (120, 1), 0, null,
null);
+ Add_Conflict (Table.States (1066), 74, (157, 1), 0, null, null);
+ Add_Action (Table.States (1066), 76, 627);
+ Add_Action (Table.States (1066), 85, 238);
+ Add_Action (Table.States (1066), 97, Reduce, (157, 1), 0, null,
null);
+ Add_Action (Table.States (1066), 102, 240);
+ Add_Action (Table.States (1066), 103, 241);
+ Table.States (1066).Goto_List.Set_Capacity (6);
+ Add_Goto (Table.States (1066), 116, 242);
+ Add_Goto (Table.States (1066), 120, 1164);
+ Add_Goto (Table.States (1066), 156, 1165);
+ Add_Goto (Table.States (1066), 157, 1166);
+ Add_Goto (Table.States (1066), 225, 629);
+ Add_Goto (Table.States (1066), 323, 243);
+ Table.States (1066).Kernel := To_Vector (((129, 240, 2, True),
(163, 240, 3, False), (163, 240, 0, False),
+ (240, 240, 5, True), (240, 240, 2, True), (273, 240, 3, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True), (294, 240, 2, True)));
+ Table.States (1066).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 157, 0)));
+ Table.States (1067).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1067), 97, 1167);
+ Table.States (1067).Kernel := To_Vector ((0 => (261, 123, 1,
False)));
+ Table.States (1067).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1167)));
+ Table.States (1068).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1068), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (207, 0), 7,
full_type_declaration_0'Access, null);
- Table.States (1058).Kernel := To_Vector ((0 => (206, 96, 0,
False)));
- Table.States (1058).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 206, 7)));
- Table.States (1059).Action_List.Set_Capacity (40);
- Add_Action (Table.States (1059), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (245, 2), 7,
+ Table.States (1068).Kernel := To_Vector ((0 => (207, 97, 0,
False)));
+ Table.States (1068).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 207, 7)));
+ Table.States (1069).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1069), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (246, 2), 7,
object_renaming_declaration_2'Access, null);
- Table.States (1059).Kernel := To_Vector ((0 => (245, 96, 0,
False)));
- Table.States (1059).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 245, 7)));
- Table.States (1060).Action_List.Set_Capacity (40);
- Add_Action (Table.States (1060), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (245, 1), 7,
+ Table.States (1069).Kernel := To_Vector ((0 => (246, 97, 0,
False)));
+ Table.States (1069).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 246, 7)));
+ Table.States (1070).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1070), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (246, 1), 7,
object_renaming_declaration_1'Access, null);
- Table.States (1060).Kernel := To_Vector ((0 => (245, 96, 0,
False)));
- Table.States (1060).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 245, 7)));
- Table.States (1061).Action_List.Set_Capacity (7);
- Add_Action (Table.States (1061), (21, 35, 56, 74, 77, 82, 96),
(114, 1), 5, access_definition_1'Access,
+ Table.States (1070).Kernel := To_Vector ((0 => (246, 97, 0,
False)));
+ Table.States (1070).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 246, 7)));
+ Table.States (1071).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (1071), (21, 35, 56, 74, 77, 83, 97),
(115, 1), 5, access_definition_1'Access,
null);
- Table.States (1061).Kernel := To_Vector ((0 => (114, 252, 0,
True)));
- Table.States (1061).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 114, 5)));
- Table.States (1061).Minimal_Complete_Actions_Recursive := True;
- Table.States (1062).Action_List.Set_Capacity (7);
- Add_Action (Table.States (1062), (21, 35, 56, 74, 77, 82, 96),
(114, 0), 5, access_definition_0'Access,
+ Table.States (1071).Kernel := To_Vector ((0 => (115, 253, 0,
True)));
+ Table.States (1071).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 115, 5)));
+ Table.States (1071).Minimal_Complete_Actions_Recursive := True;
+ Table.States (1072).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (1072), (21, 35, 56, 74, 77, 83, 97),
(115, 0), 5, access_definition_0'Access,
null);
- Table.States (1062).Kernel := To_Vector ((0 => (114, 253, 0,
False)));
- Table.States (1062).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 114, 5)));
- Table.States (1063).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1063), 96, 1157);
- Table.States (1063).Kernel := To_Vector ((0 => (245, 122, 1,
False)));
- Table.States (1063).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1157)));
- Table.States (1064).Action_List.Set_Capacity (4);
- Add_Action (Table.States (1064), 44, 915);
- Add_Action (Table.States (1064), 104, 119);
- Add_Action (Table.States (1064), 105, 33);
- Add_Action (Table.States (1064), 106, 34);
- Table.States (1064).Goto_List.Set_Capacity (6);
- Add_Goto (Table.States (1064), 128, 41);
- Add_Goto (Table.States (1064), 184, 917);
- Add_Goto (Table.States (1064), 185, 1158);
- Add_Goto (Table.States (1064), 239, 919);
- Add_Goto (Table.States (1064), 272, 92);
- Add_Goto (Table.States (1064), 293, 97);
- Table.States (1064).Kernel := To_Vector ((0 => (187, 81, 2,
False)));
- Table.States (1064).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (1065).Action_List.Set_Capacity (4);
- Add_Action (Table.States (1065), 44, 915);
- Add_Action (Table.States (1065), 104, 119);
- Add_Action (Table.States (1065), 105, 33);
- Add_Action (Table.States (1065), 106, 34);
- Table.States (1065).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (1065), 128, 41);
- Add_Goto (Table.States (1065), 184, 1159);
- Add_Goto (Table.States (1065), 239, 919);
- Add_Goto (Table.States (1065), 272, 92);
- Add_Goto (Table.States (1065), 293, 97);
- Table.States (1065).Kernel := To_Vector ((0 => (185, 79, 1,
True)));
- Table.States (1065).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (1065).Minimal_Complete_Actions_Recursive := True;
- Table.States (1066).Action_List.Set_Capacity (24);
- Add_Action (Table.States (1066), 4, 1);
- Add_Action (Table.States (1066), 5, 2);
- Add_Action (Table.States (1066), 13, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (1066), 15, 3);
- Add_Action (Table.States (1066), 17, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (1066), 18, 4);
- Add_Action (Table.States (1066), 24, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (1066), 27, 5);
- Add_Action (Table.States (1066), 28, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (1066), 31, 9);
- Add_Action (Table.States (1066), 32, 10);
- Add_Action (Table.States (1066), 37, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (1066), 41, 13);
- Add_Action (Table.States (1066), 48, 16);
- Add_Action (Table.States (1066), 52, 20);
- Add_Action (Table.States (1066), 57, 21);
- Add_Action (Table.States (1066), 58, 22);
- Add_Action (Table.States (1066), 61, 24);
- Add_Action (Table.States (1066), 72, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (1066), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (1066), 93, 31);
- Add_Action (Table.States (1066), 104, 360);
- Add_Action (Table.States (1066), 105, 33);
- Add_Action (Table.States (1066), 106, 34);
- Table.States (1066).Goto_List.Set_Capacity (31);
- Add_Goto (Table.States (1066), 113, 36);
- Add_Goto (Table.States (1066), 123, 38);
- Add_Goto (Table.States (1066), 126, 39);
- Add_Goto (Table.States (1066), 128, 41);
- Add_Goto (Table.States (1066), 131, 42);
- Add_Goto (Table.States (1066), 132, 43);
- Add_Goto (Table.States (1066), 133, 44);
- Add_Goto (Table.States (1066), 139, 47);
- Add_Goto (Table.States (1066), 151, 50);
- Add_Goto (Table.States (1066), 152, 51);
- Add_Goto (Table.States (1066), 161, 53);
- Add_Goto (Table.States (1066), 190, 57);
- Add_Goto (Table.States (1066), 196, 59);
- Add_Goto (Table.States (1066), 217, 68);
- Add_Goto (Table.States (1066), 222, 70);
- Add_Goto (Table.States (1066), 232, 72);
- Add_Goto (Table.States (1066), 239, 73);
- Add_Goto (Table.States (1066), 257, 83);
- Add_Goto (Table.States (1066), 261, 86);
- Add_Goto (Table.States (1066), 272, 92);
- Add_Goto (Table.States (1066), 276, 93);
- Add_Goto (Table.States (1066), 290, 96);
- Add_Goto (Table.States (1066), 293, 97);
- Add_Goto (Table.States (1066), 294, 98);
- Add_Goto (Table.States (1066), 298, 99);
- Add_Goto (Table.States (1066), 299, 361);
- Add_Goto (Table.States (1066), 300, 1160);
- Add_Goto (Table.States (1066), 302, 100);
- Add_Goto (Table.States (1066), 303, 101);
- Add_Goto (Table.States (1066), 306, 363);
- Add_Goto (Table.States (1066), 323, 114);
- Table.States (1066).Kernel := To_Vector ((0 => (187, 87, 0,
False)));
- Table.States (1066).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 300, 0)));
- Table.States (1067).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1067), 96, 1161);
- Table.States (1067).Kernel := To_Vector ((0 => (133, 220, 1,
False)));
- Table.States (1067).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1161)));
- Table.States (1068).Action_List.Set_Capacity (46);
- Add_Action (Table.States (1068), (4, 5, 13, 15, 17, 18, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (232, 1), 7, loop_statement_1'Access,
loop_statement_1_check'Access);
- Table.States (1068).Kernel := To_Vector ((0 => (232, 96, 0,
False)));
- Table.States (1068).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 232, 7)));
- Table.States (1069).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1069), 96, 1162);
- Table.States (1069).Kernel := To_Vector ((0 => (232, 220, 1,
False)));
- Table.States (1069).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1162)));
- Table.States (1070).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1070), 74, 337);
- Add_Action (Table.States (1070), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (1070).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (1070), 122, 1163);
- Table.States (1070).Kernel := To_Vector ((0 => (244, 192, 1,
False)));
- Table.States (1070).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (1071).Action_List.Set_Capacity (40);
- Add_Action (Table.States (1071), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (244, 4), 7,
- object_declaration_4'Access, null);
- Table.States (1071).Kernel := To_Vector ((0 => (244, 96, 0,
False)));
- Table.States (1071).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 244, 7)));
- Table.States (1072).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1072), 74, 337);
- Add_Action (Table.States (1072), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (1072).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (1072), 122, 1164);
- Table.States (1072).Kernel := To_Vector ((0 => (244, 192, 1,
False)));
- Table.States (1072).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (1073).Action_List.Set_Capacity (40);
- Add_Action (Table.States (1073), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (244, 5), 7,
- object_declaration_5'Access, null);
- Table.States (1073).Kernel := To_Vector ((0 => (244, 96, 0,
False)));
- Table.States (1073).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 244, 7)));
- Table.States (1074).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1074), 74, 337);
- Add_Action (Table.States (1074), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (1074).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (1074), 122, 1165);
- Table.States (1074).Kernel := To_Vector ((0 => (244, 192, 1,
False)));
- Table.States (1074).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (1075).Action_List.Set_Capacity (40);
- Add_Action (Table.States (1075), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (244, 3), 7,
- object_declaration_3'Access, null);
- Table.States (1075).Kernel := To_Vector ((0 => (244, 96, 0,
False)));
- Table.States (1075).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 244, 7)));
- Table.States (1076).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1076), 74, 337);
- Add_Action (Table.States (1076), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (1076).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (1076), 122, 1166);
- Table.States (1076).Kernel := To_Vector ((0 => (179, 253, 1,
False)));
- Table.States (1076).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
+ Table.States (1072).Kernel := To_Vector ((0 => (115, 254, 0,
False)));
+ Table.States (1072).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 115, 5)));
+ Table.States (1073).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1073), 97, 1168);
+ Table.States (1073).Kernel := To_Vector ((0 => (246, 123, 1,
False)));
+ Table.States (1073).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1168)));
+ Table.States (1074).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (1074), 44, 923);
+ Add_Action (Table.States (1074), 79, 31);
+ Add_Action (Table.States (1074), 105, 120);
+ Add_Action (Table.States (1074), 106, 34);
+ Add_Action (Table.States (1074), 107, 35);
+ Table.States (1074).Goto_List.Set_Capacity (6);
+ Add_Goto (Table.States (1074), 129, 42);
+ Add_Goto (Table.States (1074), 185, 925);
+ Add_Goto (Table.States (1074), 186, 1169);
+ Add_Goto (Table.States (1074), 240, 927);
+ Add_Goto (Table.States (1074), 273, 93);
+ Add_Goto (Table.States (1074), 294, 98);
+ Table.States (1074).Kernel := To_Vector ((0 => (188, 82, 2,
False)));
+ Table.States (1074).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (1075).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (1075), 44, 923);
+ Add_Action (Table.States (1075), 79, 31);
+ Add_Action (Table.States (1075), 105, 120);
+ Add_Action (Table.States (1075), 106, 34);
+ Add_Action (Table.States (1075), 107, 35);
+ Table.States (1075).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (1075), 129, 42);
+ Add_Goto (Table.States (1075), 185, 1170);
+ Add_Goto (Table.States (1075), 240, 927);
+ Add_Goto (Table.States (1075), 273, 93);
+ Add_Goto (Table.States (1075), 294, 98);
+ Table.States (1075).Kernel := To_Vector ((0 => (186, 80, 1,
True)));
+ Table.States (1075).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (1075).Minimal_Complete_Actions_Recursive := True;
+ Table.States (1076).Action_List.Set_Capacity (25);
+ Add_Action (Table.States (1076), 4, 1);
+ Add_Action (Table.States (1076), 5, 2);
+ Add_Action (Table.States (1076), 13, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (1076), 15, 3);
+ Add_Action (Table.States (1076), 17, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (1076), 18, 4);
+ Add_Action (Table.States (1076), 24, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (1076), 27, 5);
+ Add_Action (Table.States (1076), 28, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (1076), 31, 9);
+ Add_Action (Table.States (1076), 32, 10);
+ Add_Action (Table.States (1076), 37, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (1076), 41, 13);
+ Add_Action (Table.States (1076), 48, 16);
+ Add_Action (Table.States (1076), 52, 20);
+ Add_Action (Table.States (1076), 57, 21);
+ Add_Action (Table.States (1076), 58, 22);
+ Add_Action (Table.States (1076), 61, 24);
+ Add_Action (Table.States (1076), 72, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (1076), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (1076), 79, 31);
+ Add_Action (Table.States (1076), 94, 32);
+ Add_Action (Table.States (1076), 105, 361);
+ Add_Action (Table.States (1076), 106, 34);
+ Add_Action (Table.States (1076), 107, 35);
+ Table.States (1076).Goto_List.Set_Capacity (31);
+ Add_Goto (Table.States (1076), 114, 37);
+ Add_Goto (Table.States (1076), 124, 39);
+ Add_Goto (Table.States (1076), 127, 40);
+ Add_Goto (Table.States (1076), 129, 42);
+ Add_Goto (Table.States (1076), 132, 43);
+ Add_Goto (Table.States (1076), 133, 44);
+ Add_Goto (Table.States (1076), 134, 45);
+ Add_Goto (Table.States (1076), 140, 48);
+ Add_Goto (Table.States (1076), 152, 51);
+ Add_Goto (Table.States (1076), 153, 52);
+ Add_Goto (Table.States (1076), 162, 54);
+ Add_Goto (Table.States (1076), 191, 58);
+ Add_Goto (Table.States (1076), 197, 60);
+ Add_Goto (Table.States (1076), 218, 69);
+ Add_Goto (Table.States (1076), 223, 71);
+ Add_Goto (Table.States (1076), 233, 73);
+ Add_Goto (Table.States (1076), 240, 74);
+ Add_Goto (Table.States (1076), 258, 84);
+ Add_Goto (Table.States (1076), 262, 87);
+ Add_Goto (Table.States (1076), 273, 93);
+ Add_Goto (Table.States (1076), 277, 94);
+ Add_Goto (Table.States (1076), 291, 97);
+ Add_Goto (Table.States (1076), 294, 98);
+ Add_Goto (Table.States (1076), 295, 99);
+ Add_Goto (Table.States (1076), 299, 100);
+ Add_Goto (Table.States (1076), 300, 362);
+ Add_Goto (Table.States (1076), 301, 1171);
+ Add_Goto (Table.States (1076), 303, 101);
+ Add_Goto (Table.States (1076), 304, 102);
+ Add_Goto (Table.States (1076), 307, 364);
+ Add_Goto (Table.States (1076), 324, 115);
+ Table.States (1076).Kernel := To_Vector ((0 => (188, 88, 0,
False)));
+ Table.States (1076).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 301, 0)));
Table.States (1077).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1077), 96, 1167);
- Table.States (1077).Kernel := To_Vector ((0 => (213, 122, 1,
False)));
- Table.States (1077).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1167)));
- Table.States (1078).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1078), 96, 1168);
- Table.States (1078).Kernel := To_Vector ((0 => (213, 122, 1,
False)));
- Table.States (1078).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1168)));
+ Add_Action (Table.States (1077), 97, 1172);
+ Table.States (1077).Kernel := To_Vector ((0 => (134, 221, 1,
False)));
+ Table.States (1077).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1172)));
+ Table.States (1078).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (1078), (4, 5, 13, 15, 17, 18, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (233, 1), 7, loop_statement_1'Access,
loop_statement_1_check'Access);
+ Table.States (1078).Kernel := To_Vector ((0 => (233, 97, 0,
False)));
+ Table.States (1078).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 233, 7)));
Table.States (1079).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1079), 24, 1169);
- Table.States (1079).Kernel := To_Vector ((0 => (307, 218, 2,
False)));
- Table.States (1079).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1169)));
- Table.States (1080).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1080), 96, 1170);
- Table.States (1080).Kernel := To_Vector ((0 => (113, 220, 1,
False)));
- Table.States (1080).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1170)));
- Table.States (1081).Action_List.Set_Capacity (14);
- Add_Action (Table.States (1081), 3, 121);
- Add_Action (Table.States (1081), 39, 122);
- Add_Action (Table.States (1081), 40, 123);
- Add_Action (Table.States (1081), 41, 124);
- Add_Action (Table.States (1081), 52, 125);
- Add_Action (Table.States (1081), 76, 126);
- Add_Action (Table.States (1081), 77, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (1081), 83, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (1081), 94, 127);
- Add_Action (Table.States (1081), 95, 128);
- Add_Action (Table.States (1081), 103, 129);
- Add_Action (Table.States (1081), 104, 119);
- Add_Action (Table.States (1081), 105, 33);
- Add_Action (Table.States (1081), 106, 34);
- Table.States (1081).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (1081), 117, 130);
- Add_Goto (Table.States (1081), 128, 41);
- Add_Goto (Table.States (1081), 191, 131);
- Add_Goto (Table.States (1081), 192, 1171);
- Add_Goto (Table.States (1081), 197, 133);
- Add_Goto (Table.States (1081), 239, 134);
- Add_Goto (Table.States (1081), 258, 135);
- Add_Goto (Table.States (1081), 272, 92);
- Add_Goto (Table.States (1081), 275, 136);
- Add_Goto (Table.States (1081), 282, 137);
- Add_Goto (Table.States (1081), 283, 138);
- Add_Goto (Table.States (1081), 284, 139);
- Add_Goto (Table.States (1081), 285, 140);
- Add_Goto (Table.States (1081), 286, 141);
- Add_Goto (Table.States (1081), 287, 142);
- Add_Goto (Table.States (1081), 293, 97);
- Add_Goto (Table.States (1081), 301, 143);
- Add_Goto (Table.States (1081), 320, 144);
- Add_Goto (Table.States (1081), 321, 145);
- Add_Goto (Table.States (1081), 330, 146);
- Table.States (1081).Kernel := To_Vector ((0 => (137, 87, 0,
False)));
- Table.States (1081).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
+ Add_Action (Table.States (1079), 97, 1173);
+ Table.States (1079).Kernel := To_Vector ((0 => (233, 221, 1,
False)));
+ Table.States (1079).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1173)));
+ Table.States (1080).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1080), 74, 338);
+ Add_Action (Table.States (1080), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (1080).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (1080), 123, 1174);
+ Table.States (1080).Kernel := To_Vector ((0 => (245, 193, 1,
False)));
+ Table.States (1080).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (1081).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1081), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (245, 4), 7,
+ object_declaration_4'Access, null);
+ Table.States (1081).Kernel := To_Vector ((0 => (245, 97, 0,
False)));
+ Table.States (1081).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 245, 7)));
Table.States (1082).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1082), (77, 83), (138, 0), 3,
case_expression_alternative_list_0'Access, null);
- Table.States (1082).Kernel := To_Vector ((0 => (138, 137, 0,
True)));
- Table.States (1082).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 138, 3)));
- Table.States (1082).Minimal_Complete_Actions_Recursive := True;
- Table.States (1083).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1083), (1 => 77), (221, 1), 6,
if_expression_1'Access, null);
- Table.States (1083).Kernel := To_Vector ((0 => (221, 192, 0,
False)));
- Table.States (1083).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 221, 6)));
- Table.States (1084).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1084), 68, 1172);
- Table.States (1084).Kernel := To_Vector ((0 => (172, 192, 1,
False)));
- Table.States (1084).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 68, 1172)));
- Table.States (1085).Action_List.Set_Capacity (13);
- Add_Action (Table.States (1085), 3, 121);
- Add_Action (Table.States (1085), 39, 122);
- Add_Action (Table.States (1085), 40, 123);
- Add_Action (Table.States (1085), 41, 124);
- Add_Action (Table.States (1085), 52, 125);
- Add_Action (Table.States (1085), 76, 126);
- Add_Action (Table.States (1085), 77, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (1085), 94, 127);
- Add_Action (Table.States (1085), 95, 128);
- Add_Action (Table.States (1085), 103, 129);
- Add_Action (Table.States (1085), 104, 119);
- Add_Action (Table.States (1085), 105, 33);
- Add_Action (Table.States (1085), 106, 34);
- Table.States (1085).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (1085), 117, 130);
- Add_Goto (Table.States (1085), 128, 41);
- Add_Goto (Table.States (1085), 191, 131);
- Add_Goto (Table.States (1085), 192, 1173);
- Add_Goto (Table.States (1085), 197, 133);
- Add_Goto (Table.States (1085), 239, 134);
- Add_Goto (Table.States (1085), 258, 135);
- Add_Goto (Table.States (1085), 272, 92);
- Add_Goto (Table.States (1085), 275, 136);
- Add_Goto (Table.States (1085), 282, 137);
- Add_Goto (Table.States (1085), 283, 138);
- Add_Goto (Table.States (1085), 284, 139);
- Add_Goto (Table.States (1085), 285, 140);
- Add_Goto (Table.States (1085), 286, 141);
- Add_Goto (Table.States (1085), 287, 142);
- Add_Goto (Table.States (1085), 293, 97);
- Add_Goto (Table.States (1085), 301, 143);
- Add_Goto (Table.States (1085), 320, 144);
- Add_Goto (Table.States (1085), 321, 145);
- Add_Goto (Table.States (1085), 330, 146);
- Table.States (1085).Kernel := To_Vector ((0 => (221, 22, 0,
False)));
- Table.States (1085).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (1086).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1086), (22, 23, 77), (173, 0), 2,
elsif_expression_list_0'Access, null);
- Table.States (1086).Kernel := To_Vector ((0 => (173, 172, 0,
True)));
- Table.States (1086).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 173, 2)));
- Table.States (1086).Minimal_Complete_Actions_Recursive := True;
- Table.States (1087).Action_List.Set_Capacity (19);
- Add_Action (Table.States (1087), (10, 20, 21, 22, 23, 35, 37, 42,
43, 53, 68, 74, 75, 77, 79, 82, 83, 87,
- 96), (277, 0), 6, range_g_0'Access, null);
- Table.States (1087).Kernel := To_Vector ((0 => (277, 77, 0,
False)));
- Table.States (1087).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 277, 6)));
- Table.States (1088).Action_List.Set_Capacity (9);
- Add_Action (Table.States (1088), 53, 620);
- Add_Action (Table.States (1088), 76, 621);
- Add_Action (Table.States (1088), 77, Reduce, (314, 1), 3,
subtype_indication_1'Access, null);
- Add_Action (Table.States (1088), 79, Reduce, (165, 1), 3, null,
null);
- Add_Action (Table.States (1088), 83, Reduce, (314, 1), 3,
subtype_indication_1'Access, null);
- Add_Action (Table.States (1088), 84, 237);
- Add_Action (Table.States (1088), 87, Reduce, (165, 1), 3, null,
null);
- Add_Action (Table.States (1088), 101, 239);
- Add_Action (Table.States (1088), 102, 240);
- Table.States (1088).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (1088), 115, 241);
- Add_Goto (Table.States (1088), 155, 956);
- Add_Goto (Table.States (1088), 224, 623);
- Add_Goto (Table.States (1088), 322, 242);
- Table.States (1088).Kernel := To_Vector (((128, 239, 2, True),
(165, 239, 0, False), (239, 239, 5, True),
- (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True), (314, 239, 4, False), (314, 239, 0, False)));
- Table.States (1088).Minimal_Complete_Actions := To_Vector
(((Reduce, 165, 3), (Reduce, 314, 3)));
- Table.States (1089).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1089), (77, 83), (168, 0), 3, null,
null);
- Table.States (1089).Kernel := To_Vector ((0 => (168, 167, 0,
True)));
- Table.States (1089).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 168, 3)));
- Table.States (1089).Minimal_Complete_Actions_Recursive := True;
+ Add_Action (Table.States (1082), 74, 338);
+ Add_Action (Table.States (1082), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (1082).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (1082), 123, 1175);
+ Table.States (1082).Kernel := To_Vector ((0 => (245, 193, 1,
False)));
+ Table.States (1082).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (1083).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1083), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (245, 5), 7,
+ object_declaration_5'Access, null);
+ Table.States (1083).Kernel := To_Vector ((0 => (245, 97, 0,
False)));
+ Table.States (1083).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 245, 7)));
+ Table.States (1084).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1084), 74, 338);
+ Add_Action (Table.States (1084), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (1084).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (1084), 123, 1176);
+ Table.States (1084).Kernel := To_Vector ((0 => (245, 193, 1,
False)));
+ Table.States (1084).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (1085).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1085), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (245, 3), 7,
+ object_declaration_3'Access, null);
+ Table.States (1085).Kernel := To_Vector ((0 => (245, 97, 0,
False)));
+ Table.States (1085).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 245, 7)));
+ Table.States (1086).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1086), 74, 338);
+ Add_Action (Table.States (1086), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (1086).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (1086), 123, 1177);
+ Table.States (1086).Kernel := To_Vector ((0 => (180, 254, 1,
False)));
+ Table.States (1086).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (1087).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1087), 97, 1178);
+ Table.States (1087).Kernel := To_Vector ((0 => (214, 123, 1,
False)));
+ Table.States (1087).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1178)));
+ Table.States (1088).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1088), 97, 1179);
+ Table.States (1088).Kernel := To_Vector ((0 => (214, 123, 1,
False)));
+ Table.States (1088).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1179)));
+ Table.States (1089).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1089), 24, 1180);
+ Table.States (1089).Kernel := To_Vector ((0 => (308, 219, 2,
False)));
+ Table.States (1089).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1180)));
Table.States (1090).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1090), (1 => 104), (235, 0), 4, null,
null);
- Table.States (1090).Kernel := To_Vector ((0 => (235, 96, 0,
False)));
- Table.States (1090).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 235, 4)));
- Table.States (1091).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1091), 53, 1174);
- Table.States (1091).Kernel := To_Vector ((0 => (144, 301, 5,
False)));
- Table.States (1091).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 53, 1174)));
- Table.States (1092).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1092), 96, 1175);
- Table.States (1092).Kernel := To_Vector ((0 => (281, 54, 1,
False)));
- Table.States (1092).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1175)));
- Table.States (1093).Action_List.Set_Capacity (14);
- Add_Action (Table.States (1093), 3, 121);
- Add_Action (Table.States (1093), 39, 122);
- Add_Action (Table.States (1093), 40, 123);
- Add_Action (Table.States (1093), 41, 124);
- Add_Action (Table.States (1093), 52, 125);
- Add_Action (Table.States (1093), 76, 126);
- Add_Action (Table.States (1093), 77, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (1093), 94, 127);
- Add_Action (Table.States (1093), 95, 128);
- Add_Action (Table.States (1093), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (1093), 103, 129);
- Add_Action (Table.States (1093), 104, 119);
- Add_Action (Table.States (1093), 105, 33);
- Add_Action (Table.States (1093), 106, 34);
- Table.States (1093).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (1093), 117, 130);
- Add_Goto (Table.States (1093), 128, 41);
- Add_Goto (Table.States (1093), 191, 131);
- Add_Goto (Table.States (1093), 192, 1176);
- Add_Goto (Table.States (1093), 197, 133);
- Add_Goto (Table.States (1093), 239, 134);
- Add_Goto (Table.States (1093), 258, 135);
- Add_Goto (Table.States (1093), 272, 92);
- Add_Goto (Table.States (1093), 275, 136);
- Add_Goto (Table.States (1093), 282, 137);
- Add_Goto (Table.States (1093), 283, 138);
- Add_Goto (Table.States (1093), 284, 139);
- Add_Goto (Table.States (1093), 285, 140);
- Add_Goto (Table.States (1093), 286, 141);
- Add_Goto (Table.States (1093), 287, 142);
- Add_Goto (Table.States (1093), 293, 97);
- Add_Goto (Table.States (1093), 301, 143);
- Add_Goto (Table.States (1093), 320, 144);
- Add_Goto (Table.States (1093), 321, 145);
- Add_Goto (Table.States (1093), 330, 146);
- Table.States (1093).Kernel := To_Vector ((0 => (254, 82, 0,
False)));
- Table.States (1093).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- end Subr_18;
- procedure Subr_19
- is begin
- Table.States (1094).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1094), 104, 119);
- Add_Action (Table.States (1094), 105, 33);
- Add_Action (Table.States (1094), 106, 34);
- Table.States (1094).Goto_List.Set_Capacity (4);
- Add_Goto (Table.States (1094), 128, 41);
- Add_Goto (Table.States (1094), 239, 1177);
- Add_Goto (Table.States (1094), 272, 92);
- Add_Goto (Table.States (1094), 293, 97);
- Table.States (1094).Kernel := To_Vector (((254, 241, 2, False),
(254, 241, 1, False)));
- Table.States (1094).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
+ Add_Action (Table.States (1090), 97, 1181);
+ Table.States (1090).Kernel := To_Vector ((0 => (114, 221, 1,
False)));
+ Table.States (1090).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1181)));
+ Table.States (1091).Action_List.Set_Capacity (15);
+ Add_Action (Table.States (1091), 3, 122);
+ Add_Action (Table.States (1091), 39, 123);
+ Add_Action (Table.States (1091), 40, 124);
+ Add_Action (Table.States (1091), 41, 125);
+ Add_Action (Table.States (1091), 52, 126);
+ Add_Action (Table.States (1091), 76, 127);
+ Add_Action (Table.States (1091), 77, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (1091), 79, 31);
+ Add_Action (Table.States (1091), 84, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (1091), 95, 128);
+ Add_Action (Table.States (1091), 96, 129);
+ Add_Action (Table.States (1091), 104, 130);
+ Add_Action (Table.States (1091), 105, 120);
+ Add_Action (Table.States (1091), 106, 34);
+ Add_Action (Table.States (1091), 107, 35);
+ Table.States (1091).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (1091), 118, 131);
+ Add_Goto (Table.States (1091), 129, 42);
+ Add_Goto (Table.States (1091), 192, 132);
+ Add_Goto (Table.States (1091), 193, 1182);
+ Add_Goto (Table.States (1091), 198, 134);
+ Add_Goto (Table.States (1091), 240, 135);
+ Add_Goto (Table.States (1091), 259, 136);
+ Add_Goto (Table.States (1091), 273, 93);
+ Add_Goto (Table.States (1091), 276, 137);
+ Add_Goto (Table.States (1091), 283, 138);
+ Add_Goto (Table.States (1091), 284, 139);
+ Add_Goto (Table.States (1091), 285, 140);
+ Add_Goto (Table.States (1091), 286, 141);
+ Add_Goto (Table.States (1091), 287, 142);
+ Add_Goto (Table.States (1091), 288, 143);
+ Add_Goto (Table.States (1091), 294, 98);
+ Add_Goto (Table.States (1091), 302, 144);
+ Add_Goto (Table.States (1091), 321, 145);
+ Add_Goto (Table.States (1091), 322, 146);
+ Add_Goto (Table.States (1091), 331, 147);
+ Table.States (1091).Kernel := To_Vector ((0 => (138, 88, 0,
False)));
+ Table.States (1091).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (1092).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1092), (77, 84), (139, 0), 3,
case_expression_alternative_list_0'Access, null);
+ Table.States (1092).Kernel := To_Vector ((0 => (139, 138, 0,
True)));
+ Table.States (1092).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 139, 3)));
+ Table.States (1092).Minimal_Complete_Actions_Recursive := True;
+ Table.States (1093).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (1093), (35, 77, 84, 97), (125, 4), 6,
association_opt_4'Access, null);
+ Table.States (1093).Kernel := To_Vector ((0 => (125, 192, 0,
False)));
+ Table.States (1093).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 125, 6)));
+ Table.States (1094).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1094), (1 => 77), (222, 1), 6,
if_expression_1'Access, null);
+ Table.States (1094).Kernel := To_Vector ((0 => (222, 193, 0,
False)));
+ Table.States (1094).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 222, 6)));
Table.States (1095).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1095), 80, 1178);
- Table.States (1095).Kernel := To_Vector ((0 => (202, 20, 1,
False)));
- Table.States (1095).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 80, 1178)));
- Table.States (1096).Action_List.Set_Capacity (8);
- Add_Action (Table.States (1096), (29, 47, 48, 50, 69, 71, 74,
104), (201, 1), 7,
- formal_type_declaration_1'Access, null);
- Table.States (1096).Kernel := To_Vector ((0 => (201, 96, 0,
False)));
- Table.States (1096).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 201, 7)));
- Table.States (1097).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1097), (74, 96), (202, 2), 3, null,
null);
- Table.States (1097).Kernel := To_Vector ((0 => (202, 77, 0,
False)));
- Table.States (1097).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 202, 3)));
- Table.States (1098).Action_List.Set_Capacity (7);
- Add_Action (Table.States (1098), 10, 1151);
- Add_Action (Table.States (1098), 74, Reduce, (119, 1), 0, null,
null);
- Add_Action (Table.States (1098), 76, 235);
- Add_Action (Table.States (1098), 84, 237);
- Add_Action (Table.States (1098), 96, Reduce, (119, 1), 0, null,
null);
- Add_Action (Table.States (1098), 101, 239);
- Add_Action (Table.States (1098), 102, 240);
- Table.States (1098).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (1098), 115, 241);
- Add_Goto (Table.States (1098), 119, 1179);
- Add_Goto (Table.States (1098), 322, 242);
- Table.States (1098).Kernel := To_Vector (((128, 239, 2, True),
(203, 239, 2, False), (203, 239, 0, False),
- (239, 239, 5, True), (239, 239, 2, True), (272, 239, 3, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True), (293, 239, 2, True)));
- Table.States (1098).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 119, 0)));
- Table.States (1099).Action_List.Set_Capacity (8);
- Add_Action (Table.States (1099), (29, 47, 48, 50, 69, 71, 74,
104), (201, 0), 7,
- formal_type_declaration_0'Access, null);
- Table.States (1099).Kernel := To_Vector ((0 => (201, 96, 0,
False)));
- Table.States (1099).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 201, 7)));
- Table.States (1100).Action_List.Set_Capacity (21);
- Add_Action (Table.States (1100), 3, 121);
- Add_Action (Table.States (1100), 15, 258);
- Add_Action (Table.States (1100), 28, 259);
- Add_Action (Table.States (1100), 32, 260);
- Add_Action (Table.States (1100), 39, 122);
- Add_Action (Table.States (1100), 40, 261);
- Add_Action (Table.States (1100), 41, 124);
- Add_Action (Table.States (1100), 44, 263);
- Add_Action (Table.States (1100), 52, 125);
- Add_Action (Table.States (1100), 76, 126);
- Add_Action (Table.States (1100), 77, Reduce, (124, 5), 0, null,
null);
- Add_Action (Table.States (1100), 79, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (1100), 80, 1180);
- Add_Action (Table.States (1100), 83, Reduce, (124, 5), 0, null,
null);
- Add_Action (Table.States (1100), 87, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (1100), 94, 127);
- Add_Action (Table.States (1100), 95, 128);
- Add_Action (Table.States (1100), 103, 129);
- Add_Action (Table.States (1100), 104, 119);
- Add_Action (Table.States (1100), 105, 33);
- Add_Action (Table.States (1100), 106, 264);
- Table.States (1100).Goto_List.Set_Capacity (29);
- Add_Goto (Table.States (1100), 117, 130);
- Add_Goto (Table.States (1100), 124, 265);
- Add_Goto (Table.States (1100), 125, 406);
- Add_Goto (Table.States (1100), 128, 41);
- Add_Goto (Table.States (1100), 136, 267);
- Add_Goto (Table.States (1100), 153, 407);
- Add_Goto (Table.States (1100), 165, 269);
- Add_Goto (Table.States (1100), 166, 270);
- Add_Goto (Table.States (1100), 191, 408);
- Add_Goto (Table.States (1100), 197, 133);
- Add_Goto (Table.States (1100), 221, 273);
- Add_Goto (Table.States (1100), 239, 274);
- Add_Goto (Table.States (1100), 258, 135);
- Add_Goto (Table.States (1100), 272, 92);
- Add_Goto (Table.States (1100), 273, 275);
- Add_Goto (Table.States (1100), 275, 136);
- Add_Goto (Table.States (1100), 277, 409);
- Add_Goto (Table.States (1100), 278, 410);
- Add_Goto (Table.States (1100), 282, 137);
- Add_Goto (Table.States (1100), 283, 138);
- Add_Goto (Table.States (1100), 284, 139);
- Add_Goto (Table.States (1100), 285, 140);
- Add_Goto (Table.States (1100), 286, 141);
- Add_Goto (Table.States (1100), 287, 142);
- Add_Goto (Table.States (1100), 293, 97);
- Add_Goto (Table.States (1100), 301, 277);
- Add_Goto (Table.States (1100), 320, 144);
- Add_Goto (Table.States (1100), 321, 145);
- Add_Goto (Table.States (1100), 330, 146);
- Table.States (1100).Kernel := To_Vector (((115, 76, 1, False),
(115, 76, 3, False), (205, 76, 2, False),
- (239, 76, 4, True)));
- Table.States (1100).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 125, 0)));
+ Add_Action (Table.States (1095), 68, 1183);
+ Table.States (1095).Kernel := To_Vector ((0 => (173, 193, 1,
False)));
+ Table.States (1095).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 68, 1183)));
+ Table.States (1096).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (1096), 3, 122);
+ Add_Action (Table.States (1096), 39, 123);
+ Add_Action (Table.States (1096), 40, 124);
+ Add_Action (Table.States (1096), 41, 125);
+ Add_Action (Table.States (1096), 52, 126);
+ Add_Action (Table.States (1096), 76, 127);
+ Add_Action (Table.States (1096), 77, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (1096), 79, 31);
+ Add_Action (Table.States (1096), 95, 128);
+ Add_Action (Table.States (1096), 96, 129);
+ Add_Action (Table.States (1096), 104, 130);
+ Add_Action (Table.States (1096), 105, 120);
+ Add_Action (Table.States (1096), 106, 34);
+ Add_Action (Table.States (1096), 107, 35);
+ Table.States (1096).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (1096), 118, 131);
+ Add_Goto (Table.States (1096), 129, 42);
+ Add_Goto (Table.States (1096), 192, 132);
+ Add_Goto (Table.States (1096), 193, 1184);
+ Add_Goto (Table.States (1096), 198, 134);
+ Add_Goto (Table.States (1096), 240, 135);
+ Add_Goto (Table.States (1096), 259, 136);
+ Add_Goto (Table.States (1096), 273, 93);
+ Add_Goto (Table.States (1096), 276, 137);
+ Add_Goto (Table.States (1096), 283, 138);
+ Add_Goto (Table.States (1096), 284, 139);
+ Add_Goto (Table.States (1096), 285, 140);
+ Add_Goto (Table.States (1096), 286, 141);
+ Add_Goto (Table.States (1096), 287, 142);
+ Add_Goto (Table.States (1096), 288, 143);
+ Add_Goto (Table.States (1096), 294, 98);
+ Add_Goto (Table.States (1096), 302, 144);
+ Add_Goto (Table.States (1096), 321, 145);
+ Add_Goto (Table.States (1096), 322, 146);
+ Add_Goto (Table.States (1096), 331, 147);
+ Table.States (1096).Kernel := To_Vector ((0 => (222, 22, 0,
False)));
+ Table.States (1096).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (1097).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (1097), (22, 23, 77), (174, 0), 2,
elsif_expression_list_0'Access, null);
+ Table.States (1097).Kernel := To_Vector ((0 => (174, 173, 0,
True)));
+ Table.States (1097).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 174, 2)));
+ Table.States (1097).Minimal_Complete_Actions_Recursive := True;
+ Table.States (1098).Action_List.Set_Capacity (19);
+ Add_Action (Table.States (1098), (10, 20, 21, 22, 23, 35, 37, 42,
43, 53, 68, 74, 75, 77, 80, 83, 84, 88,
+ 97), (278, 0), 6, range_g_0'Access, null);
+ Table.States (1098).Kernel := To_Vector ((0 => (278, 77, 0,
False)));
+ Table.States (1098).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 278, 6)));
+ Table.States (1099).Action_List.Set_Capacity (9);
+ Add_Action (Table.States (1099), 53, 626);
+ Add_Action (Table.States (1099), 76, 627);
+ Add_Action (Table.States (1099), 77, Reduce, (315, 1), 3,
subtype_indication_1'Access, null);
+ Add_Action (Table.States (1099), 80, Reduce, (166, 1), 3, null,
null);
+ Add_Action (Table.States (1099), 84, Reduce, (315, 1), 3,
subtype_indication_1'Access, null);
+ Add_Action (Table.States (1099), 85, 238);
+ Add_Action (Table.States (1099), 88, Reduce, (166, 1), 3, null,
null);
+ Add_Action (Table.States (1099), 102, 240);
+ Add_Action (Table.States (1099), 103, 241);
+ Table.States (1099).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (1099), 116, 242);
+ Add_Goto (Table.States (1099), 156, 966);
+ Add_Goto (Table.States (1099), 225, 629);
+ Add_Goto (Table.States (1099), 323, 243);
+ Table.States (1099).Kernel := To_Vector (((129, 240, 2, True),
(166, 240, 0, False), (240, 240, 5, True),
+ (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True), (315, 240, 4, False), (315, 240, 0, False)));
+ Table.States (1099).Minimal_Complete_Actions := To_Vector
(((Reduce, 166, 3), (Reduce, 315, 3)));
+ Table.States (1100).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1100), (77, 84), (169, 0), 3, null,
null);
+ Table.States (1100).Kernel := To_Vector ((0 => (169, 168, 0,
True)));
+ Table.States (1100).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 169, 3)));
Table.States (1100).Minimal_Complete_Actions_Recursive := True;
- Table.States (1101).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1101), 74, 337);
- Add_Action (Table.States (1101), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (1101).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (1101), 122, 1181);
- Table.States (1101).Kernel := To_Vector ((0 => (204, 205, 1,
False)));
- Table.States (1101).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (1102).Action_List.Set_Capacity (8);
- Add_Action (Table.States (1102), (29, 47, 48, 50, 69, 71, 74,
104), (200, 0), 7,
- formal_subprogram_declaration_0'Access, null);
- Table.States (1102).Kernel := To_Vector ((0 => (200, 96, 0,
False)));
- Table.States (1102).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 200, 7)));
+ Table.States (1101).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1101), (1 => 105), (236, 0), 4, null,
null);
+ Table.States (1101).Kernel := To_Vector ((0 => (236, 97, 0,
False)));
+ Table.States (1101).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 236, 4)));
+ Table.States (1102).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1102), 53, 1185);
+ Table.States (1102).Kernel := To_Vector ((0 => (145, 302, 5,
False)));
+ Table.States (1102).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 53, 1185)));
Table.States (1103).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1103), 96, 1182);
- Table.States (1103).Kernel := To_Vector ((0 => (198, 122, 1,
False)));
- Table.States (1103).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1182)));
- Table.States (1104).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1104), 74, 337);
- Add_Action (Table.States (1104), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (1104).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (1104), 122, 1183);
- Table.States (1104).Kernel := To_Vector ((0 => (198, 192, 1,
False)));
- Table.States (1104).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (1105).Action_List.Set_Capacity (8);
- Add_Action (Table.States (1105), (29, 47, 48, 50, 69, 71, 74,
104), (198, 2), 7,
- formal_object_declaration_2'Access, null);
- Table.States (1105).Kernel := To_Vector ((0 => (198, 96, 0,
False)));
- Table.States (1105).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 198, 7)));
+ Add_Action (Table.States (1103), 97, 1186);
+ Table.States (1103).Kernel := To_Vector ((0 => (282, 54, 1,
False)));
+ Table.States (1103).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1186)));
+ Table.States (1104).Action_List.Set_Capacity (15);
+ Add_Action (Table.States (1104), 3, 122);
+ Add_Action (Table.States (1104), 39, 123);
+ Add_Action (Table.States (1104), 40, 124);
+ Add_Action (Table.States (1104), 41, 125);
+ Add_Action (Table.States (1104), 52, 126);
+ Add_Action (Table.States (1104), 76, 127);
+ Add_Action (Table.States (1104), 77, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (1104), 79, 31);
+ Add_Action (Table.States (1104), 95, 128);
+ Add_Action (Table.States (1104), 96, 129);
+ Add_Action (Table.States (1104), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (1104), 104, 130);
+ Add_Action (Table.States (1104), 105, 120);
+ Add_Action (Table.States (1104), 106, 34);
+ Add_Action (Table.States (1104), 107, 35);
+ Table.States (1104).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (1104), 118, 131);
+ Add_Goto (Table.States (1104), 129, 42);
+ Add_Goto (Table.States (1104), 192, 132);
+ Add_Goto (Table.States (1104), 193, 1187);
+ Add_Goto (Table.States (1104), 198, 134);
+ Add_Goto (Table.States (1104), 240, 135);
+ Add_Goto (Table.States (1104), 259, 136);
+ Add_Goto (Table.States (1104), 273, 93);
+ Add_Goto (Table.States (1104), 276, 137);
+ Add_Goto (Table.States (1104), 283, 138);
+ Add_Goto (Table.States (1104), 284, 139);
+ Add_Goto (Table.States (1104), 285, 140);
+ Add_Goto (Table.States (1104), 286, 141);
+ Add_Goto (Table.States (1104), 287, 142);
+ Add_Goto (Table.States (1104), 288, 143);
+ Add_Goto (Table.States (1104), 294, 98);
+ Add_Goto (Table.States (1104), 302, 144);
+ Add_Goto (Table.States (1104), 321, 145);
+ Add_Goto (Table.States (1104), 322, 146);
+ Add_Goto (Table.States (1104), 331, 147);
+ Table.States (1104).Kernel := To_Vector ((0 => (255, 83, 0,
False)));
+ Table.States (1104).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (1105).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (1105), 79, 31);
+ Add_Action (Table.States (1105), 105, 120);
+ Add_Action (Table.States (1105), 106, 34);
+ Add_Action (Table.States (1105), 107, 35);
+ Table.States (1105).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (1105), 129, 42);
+ Add_Goto (Table.States (1105), 240, 1188);
+ Add_Goto (Table.States (1105), 273, 93);
+ Add_Goto (Table.States (1105), 294, 98);
+ Table.States (1105).Kernel := To_Vector (((255, 242, 2, False),
(255, 242, 1, False)));
+ Table.States (1105).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
Table.States (1106).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1106), 96, 1184);
- Table.States (1106).Kernel := To_Vector ((0 => (222, 32, 1,
False)));
- Table.States (1106).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1184)));
- Table.States (1107).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1107), (22, 23, 24), (174, 0), 4,
elsif_statement_item_0'Access, null);
- Table.States (1107).Kernel := To_Vector ((0 => (174, 300, 0,
False)));
- Table.States (1107).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 174, 4)));
- Table.States (1108).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1108), 32, 1185);
- Table.States (1108).Kernel := To_Vector ((0 => (222, 24, 2,
False)));
- Table.States (1108).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 32, 1185)));
- Table.States (1109).Action_List.Set_Capacity (46);
- Add_Action (Table.States (1109), (4, 5, 13, 15, 17, 18, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (222, 2), 8, if_statement_2'Access, null);
- Table.States (1109).Kernel := To_Vector ((0 => (222, 96, 0,
False)));
- Table.States (1109).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 222, 8)));
- Table.States (1110).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1110), 24, 1186);
- Table.States (1110).Kernel := To_Vector ((0 => (247, 218, 2,
False)));
- Table.States (1110).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1186)));
- Table.States (1111).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1111), 96, 1187);
- Table.States (1111).Kernel := To_Vector ((0 => (247, 240, 1,
False)));
- Table.States (1111).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1187)));
- Table.States (1112).Action_List.Set_Capacity (4);
- Add_Action (Table.States (1112), 96, Reduce, (240, 1), 0, null,
null);
- Add_Action (Table.States (1112), 104, 119);
- Add_Action (Table.States (1112), 105, 33);
- Add_Action (Table.States (1112), 106, 34);
- Table.States (1112).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (1112), 128, 41);
- Add_Goto (Table.States (1112), 239, 632);
- Add_Goto (Table.States (1112), 240, 1188);
- Add_Goto (Table.States (1112), 272, 92);
- Add_Goto (Table.States (1112), 293, 97);
- Table.States (1112).Kernel := To_Vector ((0 => (251, 24, 0,
False)));
- Table.States (1112).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 240, 0)));
- Table.States (1113).Action_List.Set_Capacity (4);
- Add_Action (Table.States (1113), 28, 1189);
- Add_Action (Table.States (1113), 77, Reduce, (254, 4), 0, null,
null);
- Add_Action (Table.States (1113), 96, Reduce, (254, 4), 0, null,
null);
- Add_Action (Table.States (1113), 104, 164);
- Table.States (1113).Goto_List.Set_Capacity (3);
- Add_Goto (Table.States (1113), 219, 493);
- Add_Goto (Table.States (1113), 254, 494);
- Add_Goto (Table.States (1113), 255, 495);
- Table.States (1113).Kernel := To_Vector (((177, 76, 5, False),
(199, 76, 1, False)));
- Table.States (1113).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 255, 0)));
+ Add_Action (Table.States (1106), 81, 1189);
+ Table.States (1106).Kernel := To_Vector ((0 => (203, 20, 1,
False)));
+ Table.States (1106).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 81, 1189)));
+ Table.States (1107).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (1107), (29, 47, 48, 50, 69, 71, 74,
105), (202, 1), 7,
+ formal_type_declaration_1'Access, null);
+ Table.States (1107).Kernel := To_Vector ((0 => (202, 97, 0,
False)));
+ Table.States (1107).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 202, 7)));
+ Table.States (1108).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1108), (74, 97), (203, 2), 3, null,
null);
+ Table.States (1108).Kernel := To_Vector ((0 => (203, 77, 0,
False)));
+ Table.States (1108).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 203, 3)));
+ Table.States (1109).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (1109), 10, 1162);
+ Add_Action (Table.States (1109), 74, Reduce, (120, 1), 0, null,
null);
+ Add_Action (Table.States (1109), 76, 236);
+ Add_Action (Table.States (1109), 85, 238);
+ Add_Action (Table.States (1109), 97, Reduce, (120, 1), 0, null,
null);
+ Add_Action (Table.States (1109), 102, 240);
+ Add_Action (Table.States (1109), 103, 241);
+ Table.States (1109).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (1109), 116, 242);
+ Add_Goto (Table.States (1109), 120, 1190);
+ Add_Goto (Table.States (1109), 323, 243);
+ Table.States (1109).Kernel := To_Vector (((129, 240, 2, True),
(204, 240, 2, False), (204, 240, 0, False),
+ (240, 240, 5, True), (240, 240, 2, True), (273, 240, 3, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True), (294, 240, 2, True)));
+ Table.States (1109).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 120, 0)));
+ Table.States (1110).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (1110), (29, 47, 48, 50, 69, 71, 74,
105), (202, 0), 7,
+ formal_type_declaration_0'Access, null);
+ Table.States (1110).Kernel := To_Vector ((0 => (202, 97, 0,
False)));
+ Table.States (1110).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 202, 7)));
+ Table.States (1111).Action_List.Set_Capacity (22);
+ Add_Action (Table.States (1111), 3, 122);
+ Add_Action (Table.States (1111), 15, 259);
+ Add_Action (Table.States (1111), 28, 260);
+ Add_Action (Table.States (1111), 32, 261);
+ Add_Action (Table.States (1111), 39, 123);
+ Add_Action (Table.States (1111), 40, 262);
+ Add_Action (Table.States (1111), 41, 125);
+ Add_Action (Table.States (1111), 44, 264);
+ Add_Action (Table.States (1111), 52, 126);
+ Add_Action (Table.States (1111), 76, 127);
+ Add_Action (Table.States (1111), 77, Reduce, (125, 6), 0, null,
null);
+ Add_Action (Table.States (1111), 79, 31);
+ Add_Action (Table.States (1111), 80, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (1111), 81, 1191);
+ Add_Action (Table.States (1111), 84, Reduce, (125, 6), 0, null,
null);
+ Add_Action (Table.States (1111), 88, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (1111), 95, 128);
+ Add_Action (Table.States (1111), 96, 129);
+ Add_Action (Table.States (1111), 104, 130);
+ Add_Action (Table.States (1111), 105, 120);
+ Add_Action (Table.States (1111), 106, 34);
+ Add_Action (Table.States (1111), 107, 265);
+ Table.States (1111).Goto_List.Set_Capacity (29);
+ Add_Goto (Table.States (1111), 118, 131);
+ Add_Goto (Table.States (1111), 125, 266);
+ Add_Goto (Table.States (1111), 126, 407);
+ Add_Goto (Table.States (1111), 129, 42);
+ Add_Goto (Table.States (1111), 137, 268);
+ Add_Goto (Table.States (1111), 154, 408);
+ Add_Goto (Table.States (1111), 166, 270);
+ Add_Goto (Table.States (1111), 167, 271);
+ Add_Goto (Table.States (1111), 192, 409);
+ Add_Goto (Table.States (1111), 198, 134);
+ Add_Goto (Table.States (1111), 222, 274);
+ Add_Goto (Table.States (1111), 240, 275);
+ Add_Goto (Table.States (1111), 259, 136);
+ Add_Goto (Table.States (1111), 273, 93);
+ Add_Goto (Table.States (1111), 274, 276);
+ Add_Goto (Table.States (1111), 276, 137);
+ Add_Goto (Table.States (1111), 278, 410);
+ Add_Goto (Table.States (1111), 279, 411);
+ Add_Goto (Table.States (1111), 283, 138);
+ Add_Goto (Table.States (1111), 284, 139);
+ Add_Goto (Table.States (1111), 285, 140);
+ Add_Goto (Table.States (1111), 286, 141);
+ Add_Goto (Table.States (1111), 287, 142);
+ Add_Goto (Table.States (1111), 288, 143);
+ Add_Goto (Table.States (1111), 294, 98);
+ Add_Goto (Table.States (1111), 302, 278);
+ Add_Goto (Table.States (1111), 321, 145);
+ Add_Goto (Table.States (1111), 322, 146);
+ Add_Goto (Table.States (1111), 331, 147);
+ Table.States (1111).Kernel := To_Vector (((116, 76, 1, False),
(116, 76, 3, False), (206, 76, 2, False),
+ (240, 76, 4, True)));
+ Table.States (1111).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 126, 0)));
+ Table.States (1111).Minimal_Complete_Actions_Recursive := True;
+ Table.States (1112).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1112), 74, 338);
+ Add_Action (Table.States (1112), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (1112).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (1112), 123, 1192);
+ Table.States (1112).Kernel := To_Vector ((0 => (205, 206, 1,
False)));
+ Table.States (1112).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (1113).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (1113), (29, 47, 48, 50, 69, 71, 74,
105), (201, 0), 7,
+ formal_subprogram_declaration_0'Access, null);
+ Table.States (1113).Kernel := To_Vector ((0 => (201, 97, 0,
False)));
+ Table.States (1113).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 201, 7)));
Table.States (1114).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1114), 72, 1190);
- Table.States (1114).Kernel := To_Vector ((0 => (176, 177, 5,
False)));
- Table.States (1114).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 72, 1190)));
- Table.States (1115).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1115), (1 => 72), (177, 1), 1, null,
null);
- Table.States (1115).Kernel := To_Vector ((0 => (177, 253, 0,
False)));
- Table.States (1115).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 177, 1)));
- Table.States (1116).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1116), 96, 1191);
- Table.States (1116).Kernel := To_Vector ((0 => (264, 220, 1,
False)));
- Table.States (1116).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1191)));
- Table.States (1117).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1117), 10, 1006);
- Add_Action (Table.States (1117), 74, 1192);
- Table.States (1117).Kernel := To_Vector (((227, 227, 2, True),
(271, 227, 3, False)));
- Table.States (1117).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 74, 1192)));
- Table.States (1118).Action_List.Set_Capacity (40);
- Add_Action (Table.States (1118), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (271, 1), 8,
- protected_type_declaration_1'Access,
protected_type_declaration_1_check'Access);
- Table.States (1118).Kernel := To_Vector ((0 => (271, 96, 0,
False)));
- Table.States (1118).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 271, 8)));
- Table.States (1119).Action_List.Set_Capacity (7);
- Add_Action (Table.States (1119), 10, Reduce, (227, 0), 3,
interface_list_0'Access, null);
- Add_Action (Table.States (1119), 74, Reduce, (227, 0), 3,
interface_list_0'Access, null);
- Add_Action (Table.States (1119), 76, 235);
- Add_Action (Table.States (1119), 84, 237);
- Add_Action (Table.States (1119), 96, Reduce, (227, 0), 3,
interface_list_0'Access, null);
- Add_Action (Table.States (1119), 101, 239);
- Add_Action (Table.States (1119), 102, 240);
- Table.States (1119).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (1119), 115, 241);
- Add_Goto (Table.States (1119), 322, 242);
- Table.States (1119).Kernel := To_Vector (((128, 239, 2, True),
(227, 239, 0, True), (239, 239, 5, True),
- (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (1119).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 227, 3)));
- Table.States (1119).Minimal_Complete_Actions_Recursive := True;
- Table.States (1120).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1120), 96, 1193);
- Table.States (1120).Kernel := To_Vector ((0 => (304, 266, 1,
False)));
- Table.States (1120).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1193)));
- Table.States (1121).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1121), 96, Reduce, (220, 1), 0, null,
null);
- Add_Action (Table.States (1121), 104, 149);
- Table.States (1121).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (1121), 220, 1194);
- Table.States (1121).Kernel := To_Vector ((0 => (266, 24, 0,
False)));
- Table.States (1121).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 220, 0)));
- Table.States (1122).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1122), (21, 96), (194, 0), 7,
extended_return_object_declaration_0'Access, null);
- Table.States (1122).Kernel := To_Vector ((0 => (194, 192, 0,
False)));
- Table.States (1122).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 194, 7)));
- Table.States (1123).Action_List.Set_Capacity (46);
- Add_Action (Table.States (1123), (4, 5, 13, 15, 17, 18, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (126, 0), 8, asynchronous_select_0'Access, null);
- Table.States (1123).Kernel := To_Vector ((0 => (126, 96, 0,
False)));
- Table.States (1123).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 126, 8)));
- Table.States (1124).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1124), 24, 1195);
- Table.States (1124).Kernel := To_Vector ((0 => (316, 218, 2,
False)));
- Table.States (1124).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1195)));
- Table.States (1125).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1125), 10, 1006);
- Add_Action (Table.States (1125), 74, 1196);
- Table.States (1125).Kernel := To_Vector (((227, 227, 2, True),
(319, 227, 3, False)));
- Table.States (1125).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 74, 1196)));
- Table.States (1126).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1126), 96, Reduce, (220, 1), 0, null,
null);
- Add_Action (Table.States (1126), 104, 149);
- Table.States (1126).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (1126), 220, 1197);
- Table.States (1126).Kernel := To_Vector ((0 => (319, 24, 1,
False)));
- Table.States (1126).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 220, 0)));
+ Add_Action (Table.States (1114), 97, 1193);
+ Table.States (1114).Kernel := To_Vector ((0 => (199, 123, 1,
False)));
+ Table.States (1114).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1193)));
+ Table.States (1115).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1115), 74, 338);
+ Add_Action (Table.States (1115), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (1115).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (1115), 123, 1194);
+ Table.States (1115).Kernel := To_Vector ((0 => (199, 193, 1,
False)));
+ Table.States (1115).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (1116).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (1116), (29, 47, 48, 50, 69, 71, 74,
105), (199, 2), 7,
+ formal_object_declaration_2'Access, null);
+ Table.States (1116).Kernel := To_Vector ((0 => (199, 97, 0,
False)));
+ Table.States (1116).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 199, 7)));
+ Table.States (1117).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1117), 97, 1195);
+ Table.States (1117).Kernel := To_Vector ((0 => (223, 32, 1,
False)));
+ Table.States (1117).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1195)));
+ Table.States (1118).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (1118), (22, 23, 24), (175, 0), 4,
elsif_statement_item_0'Access, null);
+ Table.States (1118).Kernel := To_Vector ((0 => (175, 301, 0,
False)));
+ Table.States (1118).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 175, 4)));
+ Table.States (1119).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1119), 32, 1196);
+ Table.States (1119).Kernel := To_Vector ((0 => (223, 24, 2,
False)));
+ Table.States (1119).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 32, 1196)));
+ Table.States (1120).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (1120), (4, 5, 13, 15, 17, 18, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (223, 2), 8, if_statement_2'Access, null);
+ Table.States (1120).Kernel := To_Vector ((0 => (223, 97, 0,
False)));
+ Table.States (1120).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 223, 8)));
+ Table.States (1121).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1121), 24, 1197);
+ Table.States (1121).Kernel := To_Vector ((0 => (248, 219, 2,
False)));
+ Table.States (1121).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1197)));
+ Table.States (1122).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1122), 97, 1198);
+ Table.States (1122).Kernel := To_Vector ((0 => (248, 241, 1,
False)));
+ Table.States (1122).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1198)));
+ Table.States (1123).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (1123), 79, 31);
+ Add_Action (Table.States (1123), 97, Reduce, (241, 1), 0, null,
null);
+ Add_Action (Table.States (1123), 105, 120);
+ Add_Action (Table.States (1123), 106, 34);
+ Add_Action (Table.States (1123), 107, 35);
+ Table.States (1123).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (1123), 129, 42);
+ Add_Goto (Table.States (1123), 240, 638);
+ Add_Goto (Table.States (1123), 241, 1199);
+ Add_Goto (Table.States (1123), 273, 93);
+ Add_Goto (Table.States (1123), 294, 98);
+ Table.States (1123).Kernel := To_Vector ((0 => (252, 24, 0,
False)));
+ Table.States (1123).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 241, 0)));
+ Table.States (1124).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (1124), 28, 1200);
+ Add_Action (Table.States (1124), 77, Reduce, (255, 4), 0, null,
null);
+ Add_Action (Table.States (1124), 97, Reduce, (255, 4), 0, null,
null);
+ Add_Action (Table.States (1124), 105, 165);
+ Table.States (1124).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (1124), 220, 496);
+ Add_Goto (Table.States (1124), 255, 497);
+ Add_Goto (Table.States (1124), 256, 498);
+ Table.States (1124).Kernel := To_Vector (((178, 76, 5, False),
(200, 76, 1, False)));
+ Table.States (1124).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 256, 0)));
+ Table.States (1125).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1125), 72, 1201);
+ Table.States (1125).Kernel := To_Vector ((0 => (177, 178, 5,
False)));
+ Table.States (1125).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 72, 1201)));
+ Table.States (1126).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1126), (1 => 72), (178, 1), 1, null,
null);
+ Table.States (1126).Kernel := To_Vector ((0 => (178, 254, 0,
False)));
+ Table.States (1126).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 178, 1)));
Table.States (1127).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1127), 24, 1198);
- Table.States (1127).Kernel := To_Vector ((0 => (305, 318, 2,
False)));
- Table.States (1127).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1198)));
- Table.States (1128).Action_List.Set_Capacity (40);
- Add_Action (Table.States (1128), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (305, 1), 8,
- single_task_declaration_1'Access,
single_task_declaration_1_check'Access);
- Table.States (1128).Kernel := To_Vector ((0 => (305, 96, 0,
False)));
- Table.States (1128).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 305, 8)));
- Table.States (1129).Action_List.Set_Capacity (7);
- Add_Action (Table.States (1129), 76, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (1129), 77, Reduce, (242, 2), 3,
null_exclusion_opt_name_type_2'Access, null);
- Add_Action (Table.States (1129), 82, Reduce, (242, 2), 3,
null_exclusion_opt_name_type_2'Access, null);
- Add_Action (Table.States (1129), 84, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (1129), 96, Reduce, (242, 2), 3,
null_exclusion_opt_name_type_2'Access, null);
- Add_Action (Table.States (1129), 101, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Add_Action (Table.States (1129), 102, Reduce, (239, 5), 1,
name_5'Access, name_5_check'Access);
- Table.States (1129).Kernel := To_Vector (((239, 104, 0, False),
(242, 104, 0, False)));
- Table.States (1129).Minimal_Complete_Actions := To_Vector
(((Reduce, 239, 1), (Reduce, 242, 3)));
+ Add_Action (Table.States (1127), 97, 1202);
+ Table.States (1127).Kernel := To_Vector ((0 => (265, 221, 1,
False)));
+ Table.States (1127).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1202)));
+ Table.States (1128).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1128), 10, 1016);
+ Add_Action (Table.States (1128), 74, 1203);
+ Table.States (1128).Kernel := To_Vector (((228, 228, 2, True),
(272, 228, 3, False)));
+ Table.States (1128).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 74, 1203)));
+ Table.States (1129).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1129), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (272, 1), 8,
+ protected_type_declaration_1'Access,
protected_type_declaration_1_check'Access);
+ Table.States (1129).Kernel := To_Vector ((0 => (272, 97, 0,
False)));
+ Table.States (1129).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 272, 8)));
Table.States (1130).Action_List.Set_Capacity (7);
- Add_Action (Table.States (1130), 76, Reduce, (239, 2), 1, null,
name_2_check'Access);
- Add_Action (Table.States (1130), 77, Reduce, (242, 3), 3,
null_exclusion_opt_name_type_3'Access, null);
- Add_Action (Table.States (1130), 82, Reduce, (242, 3), 3,
null_exclusion_opt_name_type_3'Access, null);
- Add_Action (Table.States (1130), 84, Reduce, (239, 2), 1, null,
name_2_check'Access);
- Add_Action (Table.States (1130), 96, Reduce, (242, 3), 3,
null_exclusion_opt_name_type_3'Access, null);
- Add_Action (Table.States (1130), 101, Reduce, (239, 2), 1, null,
name_2_check'Access);
- Add_Action (Table.States (1130), 102, Reduce, (239, 2), 1, null,
name_2_check'Access);
- Table.States (1130).Kernel := To_Vector (((239, 293, 0, True),
(242, 293, 0, False)));
- Table.States (1130).Minimal_Complete_Actions := To_Vector
(((Reduce, 239, 1), (Reduce, 242, 3)));
+ Add_Action (Table.States (1130), 10, Reduce, (228, 0), 3,
interface_list_0'Access, null);
+ Add_Action (Table.States (1130), 74, Reduce, (228, 0), 3,
interface_list_0'Access, null);
+ Add_Action (Table.States (1130), 76, 236);
+ Add_Action (Table.States (1130), 85, 238);
+ Add_Action (Table.States (1130), 97, Reduce, (228, 0), 3,
interface_list_0'Access, null);
+ Add_Action (Table.States (1130), 102, 240);
+ Add_Action (Table.States (1130), 103, 241);
+ Table.States (1130).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (1130), 116, 242);
+ Add_Goto (Table.States (1130), 323, 243);
+ Table.States (1130).Kernel := To_Vector (((129, 240, 2, True),
(228, 240, 0, True), (240, 240, 5, True),
+ (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (1130).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 228, 3)));
Table.States (1130).Minimal_Complete_Actions_Recursive := True;
- Table.States (1131).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1131), (77, 96), (170, 1), 5, null,
null);
- Table.States (1131).Kernel := To_Vector ((0 => (170, 192, 0,
False)));
- Table.States (1131).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 170, 5)));
+ Table.States (1131).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1131), 97, 1204);
+ Table.States (1131).Kernel := To_Vector ((0 => (305, 267, 1,
False)));
+ Table.States (1131).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1204)));
+ end Subr_19;
+ procedure Subr_20
+ is begin
Table.States (1132).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1132), (77, 96), (170, 0), 5, null,
null);
- Table.States (1132).Kernel := To_Vector ((0 => (170, 192, 0,
False)));
- Table.States (1132).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 170, 5)));
- Table.States (1133).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1133), 42, 1199);
- Table.States (1133).Kernel := To_Vector ((0 => (120, 77, 2,
False)));
- Table.States (1133).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 42, 1199)));
- Table.States (1134).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1134), 42, 1200);
- Table.States (1134).Kernel := To_Vector ((0 => (120, 77, 2,
False)));
- Table.States (1134).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 42, 1200)));
- Table.States (1135).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1135), 104, 119);
- Add_Action (Table.States (1135), 105, 33);
- Add_Action (Table.States (1135), 106, 34);
- Table.States (1135).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (1135), 128, 41);
- Add_Goto (Table.States (1135), 225, 1201);
- Add_Goto (Table.States (1135), 239, 1202);
- Add_Goto (Table.States (1135), 272, 92);
- Add_Goto (Table.States (1135), 293, 97);
- Table.States (1135).Kernel := To_Vector ((0 => (226, 83, 3,
True)));
- Table.States (1135).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (1135).Minimal_Complete_Actions_Recursive := True;
- Table.States (1136).Action_List.Set_Capacity (12);
- Add_Action (Table.States (1136), 3, 121);
- Add_Action (Table.States (1136), 39, 122);
- Add_Action (Table.States (1136), 40, 123);
- Add_Action (Table.States (1136), 41, 124);
- Add_Action (Table.States (1136), 76, 126);
- Add_Action (Table.States (1136), 80, 1203);
- Add_Action (Table.States (1136), 94, 127);
- Add_Action (Table.States (1136), 95, 128);
- Add_Action (Table.States (1136), 103, 129);
- Add_Action (Table.States (1136), 104, 119);
- Add_Action (Table.States (1136), 105, 33);
- Add_Action (Table.States (1136), 106, 34);
- Table.States (1136).Goto_List.Set_Capacity (12);
- Add_Goto (Table.States (1136), 117, 130);
- Add_Goto (Table.States (1136), 128, 41);
- Add_Goto (Table.States (1136), 197, 133);
- Add_Goto (Table.States (1136), 239, 274);
- Add_Goto (Table.States (1136), 258, 135);
- Add_Goto (Table.States (1136), 272, 92);
- Add_Goto (Table.States (1136), 277, 774);
- Add_Goto (Table.States (1136), 293, 97);
- Add_Goto (Table.States (1136), 301, 479);
- Add_Goto (Table.States (1136), 320, 144);
- Add_Goto (Table.States (1136), 321, 145);
- Add_Goto (Table.States (1136), 330, 146);
- Table.States (1136).Kernel := To_Vector (((155, 53, 3, False),
(225, 53, 1, False)));
- Table.States (1136).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 80, 1203)));
- Table.States (1137).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1137), 53, 1036);
- Add_Action (Table.States (1137), 74, Reduce, (279, 1), 0, null,
null);
- Add_Action (Table.States (1137), 96, Reduce, (279, 1), 0, null,
null);
+ Add_Action (Table.States (1132), 97, Reduce, (221, 1), 0, null,
null);
+ Add_Action (Table.States (1132), 105, 150);
+ Table.States (1132).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (1132), 221, 1205);
+ Table.States (1132).Kernel := To_Vector ((0 => (267, 24, 0,
False)));
+ Table.States (1132).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 221, 0)));
+ Table.States (1133).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1133), (21, 97), (195, 0), 7,
extended_return_object_declaration_0'Access, null);
+ Table.States (1133).Kernel := To_Vector ((0 => (195, 193, 0,
False)));
+ Table.States (1133).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 195, 7)));
+ Table.States (1134).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (1134), (4, 5, 13, 15, 17, 18, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (127, 0), 8, asynchronous_select_0'Access, null);
+ Table.States (1134).Kernel := To_Vector ((0 => (127, 97, 0,
False)));
+ Table.States (1134).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 127, 8)));
+ Table.States (1135).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1135), 24, 1206);
+ Table.States (1135).Kernel := To_Vector ((0 => (317, 219, 2,
False)));
+ Table.States (1135).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1206)));
+ Table.States (1136).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1136), 10, 1016);
+ Add_Action (Table.States (1136), 74, 1207);
+ Table.States (1136).Kernel := To_Vector (((228, 228, 2, True),
(320, 228, 3, False)));
+ Table.States (1136).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 74, 1207)));
+ Table.States (1137).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1137), 97, Reduce, (221, 1), 0, null,
null);
+ Add_Action (Table.States (1137), 105, 150);
Table.States (1137).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (1137), 279, 1204);
- Table.States (1137).Kernel := To_Vector ((0 => (326, 192, 0,
False)));
- Table.States (1137).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 279, 0)));
+ Add_Goto (Table.States (1137), 221, 1208);
+ Table.States (1137).Kernel := To_Vector ((0 => (320, 24, 1,
False)));
+ Table.States (1137).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 221, 0)));
Table.States (1138).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1138), 85, 1205);
- Table.States (1138).Kernel := To_Vector ((0 => (279, 301, 2,
False)));
- Table.States (1138).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 85, 1205)));
- Table.States (1139).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1139), 10, 1006);
- Add_Action (Table.States (1139), 74, Reduce, (228, 0), 4, null,
null);
- Add_Action (Table.States (1139), 96, Reduce, (228, 0), 4, null,
null);
- Table.States (1139).Kernel := To_Vector (((227, 227, 2, True),
(228, 227, 0, False)));
- Table.States (1139).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 228, 4)));
- Table.States (1140).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1140), 10, 1006);
- Add_Action (Table.States (1140), 74, Reduce, (228, 2), 4, null,
null);
- Add_Action (Table.States (1140), 96, Reduce, (228, 2), 4, null,
null);
- Table.States (1140).Kernel := To_Vector (((227, 227, 2, True),
(228, 227, 0, False)));
- Table.States (1140).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 228, 4)));
- Table.States (1141).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1141), (74, 96), (326, 1), 4, null,
null);
- Table.States (1141).Kernel := To_Vector ((0 => (326, 301, 0,
False)));
- Table.States (1141).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 326, 4)));
- Table.States (1142).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1142), 72, 1206);
- Table.States (1142).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (1142), 328, 1207);
- Add_Goto (Table.States (1142), 329, 1208);
- Table.States (1142).Kernel := To_Vector ((0 => (327, 35, 5,
False)));
- Table.States (1142).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 72, 1206)));
+ Add_Action (Table.States (1138), 24, 1209);
+ Table.States (1138).Kernel := To_Vector ((0 => (306, 319, 2,
False)));
+ Table.States (1138).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1209)));
+ Table.States (1139).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1139), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (306, 1), 8,
+ single_task_declaration_1'Access,
single_task_declaration_1_check'Access);
+ Table.States (1139).Kernel := To_Vector ((0 => (306, 97, 0,
False)));
+ Table.States (1139).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 306, 8)));
+ Table.States (1140).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (1140), 76, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (1140), 77, Reduce, (243, 2), 3,
null_exclusion_opt_name_type_2'Access, null);
+ Add_Action (Table.States (1140), 83, Reduce, (243, 2), 3,
null_exclusion_opt_name_type_2'Access, null);
+ Add_Action (Table.States (1140), 85, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (1140), 97, Reduce, (243, 2), 3,
null_exclusion_opt_name_type_2'Access, null);
+ Add_Action (Table.States (1140), 102, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Add_Action (Table.States (1140), 103, Reduce, (240, 5), 1,
name_5'Access, name_5_check'Access);
+ Table.States (1140).Kernel := To_Vector (((240, 105, 0, False),
(243, 105, 0, False)));
+ Table.States (1140).Minimal_Complete_Actions := To_Vector
(((Reduce, 240, 1), (Reduce, 243, 3)));
+ Table.States (1141).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (1141), 76, Reduce, (240, 2), 1, null,
name_2_check'Access);
+ Add_Action (Table.States (1141), 77, Reduce, (243, 3), 3,
null_exclusion_opt_name_type_3'Access, null);
+ Add_Action (Table.States (1141), 83, Reduce, (243, 3), 3,
null_exclusion_opt_name_type_3'Access, null);
+ Add_Action (Table.States (1141), 85, Reduce, (240, 2), 1, null,
name_2_check'Access);
+ Add_Action (Table.States (1141), 97, Reduce, (243, 3), 3,
null_exclusion_opt_name_type_3'Access, null);
+ Add_Action (Table.States (1141), 102, Reduce, (240, 2), 1, null,
name_2_check'Access);
+ Add_Action (Table.States (1141), 103, Reduce, (240, 2), 1, null,
name_2_check'Access);
+ Table.States (1141).Kernel := To_Vector (((240, 294, 0, True),
(243, 294, 0, False)));
+ Table.States (1141).Minimal_Complete_Actions := To_Vector
(((Reduce, 240, 1), (Reduce, 243, 3)));
+ Table.States (1141).Minimal_Complete_Actions_Recursive := True;
+ Table.States (1142).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1142), (77, 97), (171, 1), 5, null,
null);
+ Table.States (1142).Kernel := To_Vector ((0 => (171, 193, 0,
False)));
+ Table.States (1142).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 171, 5)));
Table.States (1143).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1143), (74, 96), (280, 0), 4,
record_definition_0'Access, null);
- Table.States (1143).Kernel := To_Vector ((0 => (280, 54, 0,
False)));
- Table.States (1143).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 280, 4)));
- Table.States (1144).Action_List.Set_Capacity (5);
- Add_Action (Table.States (1144), 7, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (1144), 40, 744);
- Add_Action (Table.States (1144), 104, 119);
- Add_Action (Table.States (1144), 105, 33);
- Add_Action (Table.States (1144), 106, 34);
- Table.States (1144).Goto_List.Set_Capacity (7);
- Add_Goto (Table.States (1144), 114, 1209);
- Add_Goto (Table.States (1144), 128, 41);
- Add_Goto (Table.States (1144), 239, 484);
- Add_Goto (Table.States (1144), 241, 723);
- Add_Goto (Table.States (1144), 272, 92);
- Add_Goto (Table.States (1144), 293, 97);
- Add_Goto (Table.States (1144), 314, 1210);
- Table.States (1144).Kernel := To_Vector (((147, 8, 1, False),
(147, 8, 2, False)));
- Table.States (1144).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (1145).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1145), (74, 82, 96), (147, 3), 1, null,
null);
- Table.States (1145).Kernel := To_Vector ((0 => (147, 114, 0,
False)));
- Table.States (1145).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 147, 1)));
- Table.States (1146).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1146), 74, 337);
- Add_Action (Table.States (1146), 82, 1211);
- Add_Action (Table.States (1146), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (1146).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (1146), 122, 1212);
- Table.States (1146).Kernel := To_Vector (((146, 147, 2, False),
(146, 147, 1, False)));
- Table.States (1146).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (1147).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1147), (74, 82, 96), (147, 1), 1, null,
null);
- Table.States (1147).Kernel := To_Vector ((0 => (147, 314, 0,
False)));
- Table.States (1147).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 147, 1)));
+ Add_Action (Table.States (1143), (77, 97), (171, 0), 5, null,
null);
+ Table.States (1143).Kernel := To_Vector ((0 => (171, 193, 0,
False)));
+ Table.States (1143).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 171, 5)));
+ Table.States (1144).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1144), 42, 1210);
+ Table.States (1144).Kernel := To_Vector ((0 => (121, 77, 2,
False)));
+ Table.States (1144).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 42, 1210)));
+ Table.States (1145).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1145), 42, 1211);
+ Table.States (1145).Kernel := To_Vector ((0 => (121, 77, 2,
False)));
+ Table.States (1145).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 42, 1211)));
+ Table.States (1146).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (1146), 79, 31);
+ Add_Action (Table.States (1146), 105, 120);
+ Add_Action (Table.States (1146), 106, 34);
+ Add_Action (Table.States (1146), 107, 35);
+ Table.States (1146).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (1146), 129, 42);
+ Add_Goto (Table.States (1146), 226, 1212);
+ Add_Goto (Table.States (1146), 240, 1213);
+ Add_Goto (Table.States (1146), 273, 93);
+ Add_Goto (Table.States (1146), 294, 98);
+ Table.States (1146).Kernel := To_Vector ((0 => (227, 84, 3,
True)));
+ Table.States (1146).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (1146).Minimal_Complete_Actions_Recursive := True;
+ Table.States (1147).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (1147), 3, 122);
+ Add_Action (Table.States (1147), 39, 123);
+ Add_Action (Table.States (1147), 40, 124);
+ Add_Action (Table.States (1147), 41, 125);
+ Add_Action (Table.States (1147), 76, 127);
+ Add_Action (Table.States (1147), 79, 31);
+ Add_Action (Table.States (1147), 81, 1214);
+ Add_Action (Table.States (1147), 95, 128);
+ Add_Action (Table.States (1147), 96, 129);
+ Add_Action (Table.States (1147), 104, 130);
+ Add_Action (Table.States (1147), 105, 120);
+ Add_Action (Table.States (1147), 106, 34);
+ Add_Action (Table.States (1147), 107, 35);
+ Table.States (1147).Goto_List.Set_Capacity (12);
+ Add_Goto (Table.States (1147), 118, 131);
+ Add_Goto (Table.States (1147), 129, 42);
+ Add_Goto (Table.States (1147), 198, 134);
+ Add_Goto (Table.States (1147), 240, 275);
+ Add_Goto (Table.States (1147), 259, 136);
+ Add_Goto (Table.States (1147), 273, 93);
+ Add_Goto (Table.States (1147), 278, 782);
+ Add_Goto (Table.States (1147), 294, 98);
+ Add_Goto (Table.States (1147), 302, 482);
+ Add_Goto (Table.States (1147), 321, 145);
+ Add_Goto (Table.States (1147), 322, 146);
+ Add_Goto (Table.States (1147), 331, 147);
+ Table.States (1147).Kernel := To_Vector (((156, 53, 3, False),
(226, 53, 1, False)));
+ Table.States (1147).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 81, 1214)));
Table.States (1148).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1148), 10, 1006);
- Add_Action (Table.States (1148), 74, Reduce, (228, 3), 4, null,
null);
- Add_Action (Table.States (1148), 96, Reduce, (228, 3), 4, null,
null);
- Table.States (1148).Kernel := To_Vector (((227, 227, 2, True),
(228, 227, 0, False)));
- Table.States (1148).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 228, 4)));
- Table.States (1149).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1149), 10, 1006);
- Add_Action (Table.States (1149), 74, Reduce, (228, 1), 4, null,
null);
- Add_Action (Table.States (1149), 96, Reduce, (228, 1), 4, null,
null);
- Table.States (1149).Kernel := To_Vector (((227, 227, 2, True),
(228, 227, 0, False)));
- Table.States (1149).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 228, 4)));
- Table.States (1150).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1150), (77, 83), (181, 0), 3, null,
null);
- Table.States (1150).Kernel := To_Vector ((0 => (181, 180, 0,
True)));
- Table.States (1150).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 181, 3)));
- Table.States (1150).Minimal_Complete_Actions_Recursive := True;
+ Add_Action (Table.States (1148), 53, 1046);
+ Add_Action (Table.States (1148), 74, Reduce, (280, 1), 0, null,
null);
+ Add_Action (Table.States (1148), 97, Reduce, (280, 1), 0, null,
null);
+ Table.States (1148).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (1148), 280, 1215);
+ Table.States (1148).Kernel := To_Vector ((0 => (327, 193, 0,
False)));
+ Table.States (1148).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 280, 0)));
+ Table.States (1149).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1149), 86, 1216);
+ Table.States (1149).Kernel := To_Vector ((0 => (280, 302, 2,
False)));
+ Table.States (1149).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 86, 1216)));
+ Table.States (1150).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (1150), 10, 1016);
+ Add_Action (Table.States (1150), 74, Reduce, (229, 0), 4, null,
null);
+ Add_Action (Table.States (1150), 97, Reduce, (229, 0), 4, null,
null);
+ Table.States (1150).Kernel := To_Vector (((228, 228, 2, True),
(229, 228, 0, False)));
+ Table.States (1150).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 229, 4)));
Table.States (1151).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1151), 104, 119);
- Add_Action (Table.States (1151), 105, 33);
- Add_Action (Table.States (1151), 106, 34);
- Table.States (1151).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (1151), 128, 41);
- Add_Goto (Table.States (1151), 227, 1213);
- Add_Goto (Table.States (1151), 239, 842);
- Add_Goto (Table.States (1151), 272, 92);
- Add_Goto (Table.States (1151), 293, 97);
- Table.States (1151).Kernel := To_Vector ((0 => (119, 10, 1,
False)));
- Table.States (1151).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (1152).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1152), 74, 1214);
- Table.States (1152).Kernel := To_Vector ((0 => (259, 119, 3,
False)));
- Table.States (1152).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 74, 1214)));
+ Add_Action (Table.States (1151), 10, 1016);
+ Add_Action (Table.States (1151), 74, Reduce, (229, 2), 4, null,
null);
+ Add_Action (Table.States (1151), 97, Reduce, (229, 2), 4, null,
null);
+ Table.States (1151).Kernel := To_Vector (((228, 228, 2, True),
(229, 228, 0, False)));
+ Table.States (1151).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 229, 4)));
+ Table.States (1152).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1152), (74, 97), (327, 1), 4, null,
null);
+ Table.States (1152).Kernel := To_Vector ((0 => (327, 302, 0,
False)));
+ Table.States (1152).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 327, 4)));
Table.States (1153).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1153), 74, 1215);
- Table.States (1153).Kernel := To_Vector ((0 => (162, 119, 3,
False)));
- Table.States (1153).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 74, 1215)));
+ Add_Action (Table.States (1153), 72, 1217);
+ Table.States (1153).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (1153), 329, 1218);
+ Add_Goto (Table.States (1153), 330, 1219);
+ Table.States (1153).Kernel := To_Vector ((0 => (328, 35, 5,
False)));
+ Table.States (1153).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 72, 1217)));
Table.States (1154).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1154), (74, 96), (156, 0), 1, null,
null);
- Table.States (1154).Kernel := To_Vector ((0 => (156, 155, 0,
False)));
- Table.States (1154).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 156, 1)));
- Table.States (1155).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1155), (74, 96), (162, 1), 4,
derived_type_definition_1'Access, null);
- Table.States (1155).Kernel := To_Vector ((0 => (162, 156, 0,
False)));
- Table.States (1155).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 162, 4)));
- Table.States (1156).Action_List.Set_Capacity (40);
- Add_Action (Table.States (1156), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (260, 0), 8,
- private_type_declaration_0'Access, null);
- Table.States (1156).Kernel := To_Vector ((0 => (260, 96, 0,
False)));
- Table.States (1156).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 260, 8)));
- Table.States (1157).Action_List.Set_Capacity (40);
- Add_Action (Table.States (1157), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (245, 0), 8,
- object_renaming_declaration_0'Access, null);
- Table.States (1157).Kernel := To_Vector ((0 => (245, 96, 0,
False)));
- Table.States (1157).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 245, 8)));
- Table.States (1158).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1158), 79, 1065);
- Add_Action (Table.States (1158), 87, 1216);
- Table.States (1158).Kernel := To_Vector (((185, 185, 2, True),
(187, 185, 1, False)));
- Table.States (1158).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 87, 1216)));
- Table.States (1159).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1159), (79, 87), (185, 0), 3, null,
null);
- Table.States (1159).Kernel := To_Vector ((0 => (185, 184, 0,
True)));
- Table.States (1159).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 185, 3)));
- Table.States (1159).Minimal_Complete_Actions_Recursive := True;
- Table.States (1160).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1160), (24, 72), (187, 1), 4,
exception_handler_1'Access, null);
- Table.States (1160).Kernel := To_Vector ((0 => (187, 300, 0,
False)));
- Table.States (1160).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 187, 4)));
- Table.States (1161).Action_List.Set_Capacity (46);
- Add_Action (Table.States (1161), (4, 5, 13, 15, 17, 18, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (133, 0), 8, block_statement_0'Access,
block_statement_0_check'Access);
- Table.States (1161).Kernel := To_Vector ((0 => (133, 96, 0,
False)));
- Table.States (1161).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 133, 8)));
- Table.States (1162).Action_List.Set_Capacity (46);
- Add_Action (Table.States (1162), (4, 5, 13, 15, 17, 18, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (232, 0), 8, loop_statement_0'Access,
loop_statement_0_check'Access);
- Table.States (1162).Kernel := To_Vector ((0 => (232, 96, 0,
False)));
- Table.States (1162).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 232, 8)));
+ Add_Action (Table.States (1154), (74, 97), (281, 0), 4,
record_definition_0'Access, null);
+ Table.States (1154).Kernel := To_Vector ((0 => (281, 54, 0,
False)));
+ Table.States (1154).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 281, 4)));
+ Table.States (1155).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (1155), 7, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (1155), 40, 750);
+ Add_Action (Table.States (1155), 79, 31);
+ Add_Action (Table.States (1155), 105, 120);
+ Add_Action (Table.States (1155), 106, 34);
+ Add_Action (Table.States (1155), 107, 35);
+ Table.States (1155).Goto_List.Set_Capacity (7);
+ Add_Goto (Table.States (1155), 115, 1220);
+ Add_Goto (Table.States (1155), 129, 42);
+ Add_Goto (Table.States (1155), 240, 487);
+ Add_Goto (Table.States (1155), 242, 729);
+ Add_Goto (Table.States (1155), 273, 93);
+ Add_Goto (Table.States (1155), 294, 98);
+ Add_Goto (Table.States (1155), 315, 1221);
+ Table.States (1155).Kernel := To_Vector (((148, 8, 1, False),
(148, 8, 2, False)));
+ Table.States (1155).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (1156).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (1156), (74, 83, 97), (148, 3), 1, null,
null);
+ Table.States (1156).Kernel := To_Vector ((0 => (148, 115, 0,
False)));
+ Table.States (1156).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 148, 1)));
+ Table.States (1157).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (1157), 74, 338);
+ Add_Action (Table.States (1157), 83, 1222);
+ Add_Action (Table.States (1157), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (1157).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (1157), 123, 1223);
+ Table.States (1157).Kernel := To_Vector (((147, 148, 2, False),
(147, 148, 1, False)));
+ Table.States (1157).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (1158).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (1158), (74, 83, 97), (148, 1), 1, null,
null);
+ Table.States (1158).Kernel := To_Vector ((0 => (148, 315, 0,
False)));
+ Table.States (1158).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 148, 1)));
+ Table.States (1159).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (1159), 10, 1016);
+ Add_Action (Table.States (1159), 74, Reduce, (229, 3), 4, null,
null);
+ Add_Action (Table.States (1159), 97, Reduce, (229, 3), 4, null,
null);
+ Table.States (1159).Kernel := To_Vector (((228, 228, 2, True),
(229, 228, 0, False)));
+ Table.States (1159).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 229, 4)));
+ Table.States (1160).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (1160), 10, 1016);
+ Add_Action (Table.States (1160), 74, Reduce, (229, 1), 4, null,
null);
+ Add_Action (Table.States (1160), 97, Reduce, (229, 1), 4, null,
null);
+ Table.States (1160).Kernel := To_Vector (((228, 228, 2, True),
(229, 228, 0, False)));
+ Table.States (1160).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 229, 4)));
+ Table.States (1161).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1161), (77, 84), (182, 0), 3, null,
null);
+ Table.States (1161).Kernel := To_Vector ((0 => (182, 181, 0,
True)));
+ Table.States (1161).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 182, 3)));
+ Table.States (1161).Minimal_Complete_Actions_Recursive := True;
+ Table.States (1162).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (1162), 79, 31);
+ Add_Action (Table.States (1162), 105, 120);
+ Add_Action (Table.States (1162), 106, 34);
+ Add_Action (Table.States (1162), 107, 35);
+ Table.States (1162).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (1162), 129, 42);
+ Add_Goto (Table.States (1162), 228, 1224);
+ Add_Goto (Table.States (1162), 240, 850);
+ Add_Goto (Table.States (1162), 273, 93);
+ Add_Goto (Table.States (1162), 294, 98);
+ Table.States (1162).Kernel := To_Vector ((0 => (120, 10, 1,
False)));
+ Table.States (1162).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
Table.States (1163).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1163), 96, 1217);
- Table.States (1163).Kernel := To_Vector ((0 => (244, 122, 1,
False)));
- Table.States (1163).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1217)));
+ Add_Action (Table.States (1163), 74, 1225);
+ Table.States (1163).Kernel := To_Vector ((0 => (260, 120, 3,
False)));
+ Table.States (1163).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 74, 1225)));
Table.States (1164).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1164), 96, 1218);
- Table.States (1164).Kernel := To_Vector ((0 => (244, 122, 1,
False)));
- Table.States (1164).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1218)));
- Table.States (1165).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1165), 96, 1219);
- Table.States (1165).Kernel := To_Vector ((0 => (244, 122, 1,
False)));
- Table.States (1165).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1219)));
- Table.States (1166).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1166), 96, 1220);
- Table.States (1166).Kernel := To_Vector ((0 => (179, 122, 1,
False)));
- Table.States (1166).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1220)));
- Table.States (1167).Action_List.Set_Capacity (40);
+ Add_Action (Table.States (1164), 74, 1226);
+ Table.States (1164).Kernel := To_Vector ((0 => (163, 120, 3,
False)));
+ Table.States (1164).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 74, 1226)));
+ Table.States (1165).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1165), (74, 97), (157, 0), 1, null,
null);
+ Table.States (1165).Kernel := To_Vector ((0 => (157, 156, 0,
False)));
+ Table.States (1165).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 157, 1)));
+ Table.States (1166).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1166), (74, 97), (163, 1), 4,
derived_type_definition_1'Access, null);
+ Table.States (1166).Kernel := To_Vector ((0 => (163, 157, 0,
False)));
+ Table.States (1166).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 163, 4)));
+ Table.States (1167).Action_List.Set_Capacity (41);
Add_Action (Table.States (1167), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (213, 2), 8,
- generic_instantiation_2'Access, null);
- Table.States (1167).Kernel := To_Vector ((0 => (213, 96, 0,
False)));
- Table.States (1167).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 213, 8)));
- Table.States (1168).Action_List.Set_Capacity (40);
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (261, 0), 8,
+ private_type_declaration_0'Access, null);
+ Table.States (1167).Kernel := To_Vector ((0 => (261, 97, 0,
False)));
+ Table.States (1167).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 261, 8)));
+ Table.States (1168).Action_List.Set_Capacity (41);
Add_Action (Table.States (1168), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (213, 1), 8,
- generic_instantiation_1'Access, null);
- Table.States (1168).Kernel := To_Vector ((0 => (213, 96, 0,
False)));
- Table.States (1168).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 213, 8)));
- Table.States (1169).Action_List.Set_Capacity (4);
- Add_Action (Table.States (1169), 96, Reduce, (240, 1), 0, null,
null);
- Add_Action (Table.States (1169), 104, 119);
- Add_Action (Table.States (1169), 105, 33);
- Add_Action (Table.States (1169), 106, 34);
- Table.States (1169).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (1169), 128, 41);
- Add_Goto (Table.States (1169), 239, 632);
- Add_Goto (Table.States (1169), 240, 1221);
- Add_Goto (Table.States (1169), 272, 92);
- Add_Goto (Table.States (1169), 293, 97);
- Table.States (1169).Kernel := To_Vector ((0 => (307, 24, 1,
False)));
- Table.States (1169).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 240, 0)));
- Table.States (1170).Action_List.Set_Capacity (46);
- Add_Action (Table.States (1170), (4, 5, 13, 15, 17, 18, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (113, 0), 9, accept_statement_0'Access,
accept_statement_0_check'Access);
- Table.States (1170).Kernel := To_Vector ((0 => (113, 96, 0,
False)));
- Table.States (1170).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 113, 9)));
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (246, 0), 8,
+ object_renaming_declaration_0'Access, null);
+ Table.States (1168).Kernel := To_Vector ((0 => (246, 97, 0,
False)));
+ Table.States (1168).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 246, 8)));
+ Table.States (1169).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1169), 80, 1075);
+ Add_Action (Table.States (1169), 88, 1227);
+ Table.States (1169).Kernel := To_Vector (((186, 186, 2, True),
(188, 186, 1, False)));
+ Table.States (1169).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 88, 1227)));
+ Table.States (1170).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1170), (80, 88), (186, 0), 3, null,
null);
+ Table.States (1170).Kernel := To_Vector ((0 => (186, 185, 0,
True)));
+ Table.States (1170).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 186, 3)));
+ Table.States (1170).Minimal_Complete_Actions_Recursive := True;
Table.States (1171).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1171), (77, 83), (137, 0), 4,
case_expression_alternative_0'Access, null);
- Table.States (1171).Kernel := To_Vector ((0 => (137, 192, 0,
False)));
- Table.States (1171).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 137, 4)));
- Table.States (1172).Action_List.Set_Capacity (15);
- Add_Action (Table.States (1172), 3, 121);
- Add_Action (Table.States (1172), 22, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (1172), 23, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (1172), 39, 122);
- Add_Action (Table.States (1172), 40, 123);
- Add_Action (Table.States (1172), 41, 124);
- Add_Action (Table.States (1172), 52, 125);
- Add_Action (Table.States (1172), 76, 126);
- Add_Action (Table.States (1172), 77, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (1172), 94, 127);
- Add_Action (Table.States (1172), 95, 128);
- Add_Action (Table.States (1172), 103, 129);
- Add_Action (Table.States (1172), 104, 119);
- Add_Action (Table.States (1172), 105, 33);
- Add_Action (Table.States (1172), 106, 34);
- Table.States (1172).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (1172), 117, 130);
- Add_Goto (Table.States (1172), 128, 41);
- Add_Goto (Table.States (1172), 191, 131);
- Add_Goto (Table.States (1172), 192, 1222);
- Add_Goto (Table.States (1172), 197, 133);
- Add_Goto (Table.States (1172), 239, 134);
- Add_Goto (Table.States (1172), 258, 135);
- Add_Goto (Table.States (1172), 272, 92);
- Add_Goto (Table.States (1172), 275, 136);
- Add_Goto (Table.States (1172), 282, 137);
- Add_Goto (Table.States (1172), 283, 138);
- Add_Goto (Table.States (1172), 284, 139);
- Add_Goto (Table.States (1172), 285, 140);
- Add_Goto (Table.States (1172), 286, 141);
- Add_Goto (Table.States (1172), 287, 142);
- Add_Goto (Table.States (1172), 293, 97);
- Add_Goto (Table.States (1172), 301, 143);
- Add_Goto (Table.States (1172), 320, 144);
- Add_Goto (Table.States (1172), 321, 145);
- Add_Goto (Table.States (1172), 330, 146);
- Table.States (1172).Kernel := To_Vector ((0 => (172, 68, 0,
False)));
- Table.States (1172).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (1173).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1173), (1 => 77), (221, 0), 7,
if_expression_0'Access, null);
- Table.States (1173).Kernel := To_Vector ((0 => (221, 192, 0,
False)));
- Table.States (1173).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 221, 7)));
- Table.States (1174).Action_List.Set_Capacity (11);
- Add_Action (Table.States (1174), 3, 121);
- Add_Action (Table.States (1174), 39, 122);
- Add_Action (Table.States (1174), 40, 123);
- Add_Action (Table.States (1174), 41, 124);
- Add_Action (Table.States (1174), 76, 126);
- Add_Action (Table.States (1174), 94, 127);
- Add_Action (Table.States (1174), 95, 128);
- Add_Action (Table.States (1174), 103, 129);
- Add_Action (Table.States (1174), 104, 119);
- Add_Action (Table.States (1174), 105, 33);
- Add_Action (Table.States (1174), 106, 34);
- Table.States (1174).Goto_List.Set_Capacity (11);
- Add_Goto (Table.States (1174), 117, 130);
- Add_Goto (Table.States (1174), 128, 41);
- Add_Goto (Table.States (1174), 197, 133);
- Add_Goto (Table.States (1174), 239, 134);
- Add_Goto (Table.States (1174), 258, 135);
- Add_Goto (Table.States (1174), 272, 92);
- Add_Goto (Table.States (1174), 293, 97);
- Add_Goto (Table.States (1174), 301, 1223);
- Add_Goto (Table.States (1174), 320, 144);
- Add_Goto (Table.States (1174), 321, 145);
- Add_Goto (Table.States (1174), 330, 146);
- Table.States (1174).Kernel := To_Vector ((0 => (144, 53, 4,
False)));
- Table.States (1174).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
- Table.States (1175).Action_List.Set_Capacity (41);
- Add_Action (Table.States (1175), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73,
74, 93, 104, 105, 106, 107), (281, 0), 9,
- record_representation_clause_0'Access, null);
- Table.States (1175).Kernel := To_Vector ((0 => (281, 96, 0,
False)));
- Table.States (1175).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 281, 9)));
- Table.States (1176).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1176), (77, 96), (254, 2), 6,
parameter_specification_2'Access, null);
- Table.States (1176).Kernel := To_Vector ((0 => (254, 192, 0,
False)));
- Table.States (1176).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 254, 6)));
- Table.States (1177).Action_List.Set_Capacity (7);
- Add_Action (Table.States (1177), 76, 235);
- Add_Action (Table.States (1177), 77, Reduce, (254, 1), 6,
parameter_specification_1'Access, null);
- Add_Action (Table.States (1177), 82, 1224);
- Add_Action (Table.States (1177), 84, 237);
- Add_Action (Table.States (1177), 96, Reduce, (254, 1), 6,
parameter_specification_1'Access, null);
- Add_Action (Table.States (1177), 101, 239);
- Add_Action (Table.States (1177), 102, 240);
- Table.States (1177).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (1177), 115, 241);
- Add_Goto (Table.States (1177), 322, 242);
- Table.States (1177).Kernel := To_Vector (((128, 239, 2, True),
(239, 239, 5, True), (239, 239, 2, True),
- (254, 239, 1, False), (254, 239, 0, False), (272, 239, 3, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True), (293, 239, 2, True)));
- Table.States (1177).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 254, 6)));
- Table.States (1178).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1178), (74, 96), (202, 6), 4, null,
null);
- Table.States (1178).Kernel := To_Vector ((0 => (202, 80, 0,
False)));
- Table.States (1178).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 202, 4)));
- Table.States (1179).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1179), 74, 1225);
- Add_Conflict (Table.States (1179), 74, (203, 1), 4,
formal_derived_type_definition_1'Access, null);
- Add_Action (Table.States (1179), 96, Reduce, (203, 1), 4,
formal_derived_type_definition_1'Access, null);
- Table.States (1179).Kernel := To_Vector (((203, 119, 2, False),
(203, 119, 0, False)));
- Table.States (1179).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 203, 4)));
- Table.States (1180).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1180), 77, 1226);
- Table.States (1180).Kernel := To_Vector ((0 => (205, 80, 1,
False)));
- Table.States (1180).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 1226)));
- Table.States (1181).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1181), 96, 1227);
- Table.States (1181).Kernel := To_Vector ((0 => (204, 122, 1,
False)));
- Table.States (1181).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1227)));
- Table.States (1182).Action_List.Set_Capacity (8);
- Add_Action (Table.States (1182), (29, 47, 48, 50, 69, 71, 74,
104), (198, 1), 8,
+ Add_Action (Table.States (1171), (24, 72), (188, 1), 4,
exception_handler_1'Access, null);
+ Table.States (1171).Kernel := To_Vector ((0 => (188, 301, 0,
False)));
+ Table.States (1171).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 188, 4)));
+ Table.States (1172).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (1172), (4, 5, 13, 15, 17, 18, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (134, 0), 8, block_statement_0'Access,
block_statement_0_check'Access);
+ Table.States (1172).Kernel := To_Vector ((0 => (134, 97, 0,
False)));
+ Table.States (1172).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 134, 8)));
+ Table.States (1173).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (1173), (4, 5, 13, 15, 17, 18, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (233, 0), 8, loop_statement_0'Access,
loop_statement_0_check'Access);
+ Table.States (1173).Kernel := To_Vector ((0 => (233, 97, 0,
False)));
+ Table.States (1173).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 233, 8)));
+ Table.States (1174).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1174), 97, 1228);
+ Table.States (1174).Kernel := To_Vector ((0 => (245, 123, 1,
False)));
+ Table.States (1174).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1228)));
+ Table.States (1175).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1175), 97, 1229);
+ Table.States (1175).Kernel := To_Vector ((0 => (245, 123, 1,
False)));
+ Table.States (1175).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1229)));
+ Table.States (1176).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1176), 97, 1230);
+ Table.States (1176).Kernel := To_Vector ((0 => (245, 123, 1,
False)));
+ Table.States (1176).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1230)));
+ Table.States (1177).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1177), 97, 1231);
+ Table.States (1177).Kernel := To_Vector ((0 => (180, 123, 1,
False)));
+ Table.States (1177).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1231)));
+ Table.States (1178).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1178), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (214, 2), 8,
+ generic_instantiation_2'Access, null);
+ Table.States (1178).Kernel := To_Vector ((0 => (214, 97, 0,
False)));
+ Table.States (1178).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 214, 8)));
+ Table.States (1179).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1179), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (214, 1), 8,
+ generic_instantiation_1'Access, null);
+ Table.States (1179).Kernel := To_Vector ((0 => (214, 97, 0,
False)));
+ Table.States (1179).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 214, 8)));
+ Table.States (1180).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (1180), 79, 31);
+ Add_Action (Table.States (1180), 97, Reduce, (241, 1), 0, null,
null);
+ Add_Action (Table.States (1180), 105, 120);
+ Add_Action (Table.States (1180), 106, 34);
+ Add_Action (Table.States (1180), 107, 35);
+ Table.States (1180).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (1180), 129, 42);
+ Add_Goto (Table.States (1180), 240, 638);
+ Add_Goto (Table.States (1180), 241, 1232);
+ Add_Goto (Table.States (1180), 273, 93);
+ Add_Goto (Table.States (1180), 294, 98);
+ Table.States (1180).Kernel := To_Vector ((0 => (308, 24, 1,
False)));
+ Table.States (1180).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 241, 0)));
+ Table.States (1181).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (1181), (4, 5, 13, 15, 17, 18, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (114, 0), 9, accept_statement_0'Access,
accept_statement_0_check'Access);
+ Table.States (1181).Kernel := To_Vector ((0 => (114, 97, 0,
False)));
+ Table.States (1181).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 114, 9)));
+ Table.States (1182).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1182), (77, 84), (138, 0), 4,
case_expression_alternative_0'Access, null);
+ Table.States (1182).Kernel := To_Vector ((0 => (138, 193, 0,
False)));
+ Table.States (1182).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 138, 4)));
+ Table.States (1183).Action_List.Set_Capacity (16);
+ Add_Action (Table.States (1183), 3, 122);
+ Add_Action (Table.States (1183), 22, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (1183), 23, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (1183), 39, 123);
+ Add_Action (Table.States (1183), 40, 124);
+ Add_Action (Table.States (1183), 41, 125);
+ Add_Action (Table.States (1183), 52, 126);
+ Add_Action (Table.States (1183), 76, 127);
+ Add_Action (Table.States (1183), 77, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (1183), 79, 31);
+ Add_Action (Table.States (1183), 95, 128);
+ Add_Action (Table.States (1183), 96, 129);
+ Add_Action (Table.States (1183), 104, 130);
+ Add_Action (Table.States (1183), 105, 120);
+ Add_Action (Table.States (1183), 106, 34);
+ Add_Action (Table.States (1183), 107, 35);
+ Table.States (1183).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (1183), 118, 131);
+ Add_Goto (Table.States (1183), 129, 42);
+ Add_Goto (Table.States (1183), 192, 132);
+ Add_Goto (Table.States (1183), 193, 1233);
+ Add_Goto (Table.States (1183), 198, 134);
+ Add_Goto (Table.States (1183), 240, 135);
+ Add_Goto (Table.States (1183), 259, 136);
+ Add_Goto (Table.States (1183), 273, 93);
+ Add_Goto (Table.States (1183), 276, 137);
+ Add_Goto (Table.States (1183), 283, 138);
+ Add_Goto (Table.States (1183), 284, 139);
+ Add_Goto (Table.States (1183), 285, 140);
+ Add_Goto (Table.States (1183), 286, 141);
+ Add_Goto (Table.States (1183), 287, 142);
+ Add_Goto (Table.States (1183), 288, 143);
+ Add_Goto (Table.States (1183), 294, 98);
+ Add_Goto (Table.States (1183), 302, 144);
+ Add_Goto (Table.States (1183), 321, 145);
+ Add_Goto (Table.States (1183), 322, 146);
+ Add_Goto (Table.States (1183), 331, 147);
+ Table.States (1183).Kernel := To_Vector ((0 => (173, 68, 0,
False)));
+ Table.States (1183).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (1184).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1184), (1 => 77), (222, 0), 7,
if_expression_0'Access, null);
+ Table.States (1184).Kernel := To_Vector ((0 => (222, 193, 0,
False)));
+ Table.States (1184).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 222, 7)));
+ Table.States (1185).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (1185), 3, 122);
+ Add_Action (Table.States (1185), 39, 123);
+ Add_Action (Table.States (1185), 40, 124);
+ Add_Action (Table.States (1185), 41, 125);
+ Add_Action (Table.States (1185), 76, 127);
+ Add_Action (Table.States (1185), 79, 31);
+ Add_Action (Table.States (1185), 95, 128);
+ Add_Action (Table.States (1185), 96, 129);
+ Add_Action (Table.States (1185), 104, 130);
+ Add_Action (Table.States (1185), 105, 120);
+ Add_Action (Table.States (1185), 106, 34);
+ Add_Action (Table.States (1185), 107, 35);
+ Table.States (1185).Goto_List.Set_Capacity (11);
+ Add_Goto (Table.States (1185), 118, 131);
+ Add_Goto (Table.States (1185), 129, 42);
+ Add_Goto (Table.States (1185), 198, 134);
+ Add_Goto (Table.States (1185), 240, 135);
+ Add_Goto (Table.States (1185), 259, 136);
+ Add_Goto (Table.States (1185), 273, 93);
+ Add_Goto (Table.States (1185), 294, 98);
+ Add_Goto (Table.States (1185), 302, 1234);
+ Add_Goto (Table.States (1185), 321, 145);
+ Add_Goto (Table.States (1185), 322, 146);
+ Add_Goto (Table.States (1185), 331, 147);
+ Table.States (1185).Kernel := To_Vector ((0 => (145, 53, 4,
False)));
+ Table.States (1185).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
+ Table.States (1186).Action_List.Set_Capacity (42);
+ Add_Action (Table.States (1186), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73,
74, 79, 94, 105, 106, 107, 108), (282, 0),
+ 9, record_representation_clause_0'Access, null);
+ Table.States (1186).Kernel := To_Vector ((0 => (282, 97, 0,
False)));
+ Table.States (1186).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 282, 9)));
+ Table.States (1187).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1187), (77, 97), (255, 2), 6,
parameter_specification_2'Access, null);
+ Table.States (1187).Kernel := To_Vector ((0 => (255, 193, 0,
False)));
+ Table.States (1187).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 255, 6)));
+ Table.States (1188).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (1188), 76, 236);
+ Add_Action (Table.States (1188), 77, Reduce, (255, 1), 6,
parameter_specification_1'Access, null);
+ Add_Action (Table.States (1188), 83, 1235);
+ Add_Action (Table.States (1188), 85, 238);
+ Add_Action (Table.States (1188), 97, Reduce, (255, 1), 6,
parameter_specification_1'Access, null);
+ Add_Action (Table.States (1188), 102, 240);
+ Add_Action (Table.States (1188), 103, 241);
+ Table.States (1188).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (1188), 116, 242);
+ Add_Goto (Table.States (1188), 323, 243);
+ Table.States (1188).Kernel := To_Vector (((129, 240, 2, True),
(240, 240, 5, True), (240, 240, 2, True),
+ (255, 240, 1, False), (255, 240, 0, False), (273, 240, 3, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True), (294, 240, 2, True)));
+ Table.States (1188).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 255, 6)));
+ Table.States (1189).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1189), (74, 97), (203, 6), 4, null,
null);
+ Table.States (1189).Kernel := To_Vector ((0 => (203, 81, 0,
False)));
+ Table.States (1189).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 203, 4)));
+ Table.States (1190).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1190), 74, 1236);
+ Add_Conflict (Table.States (1190), 74, (204, 1), 4,
formal_derived_type_definition_1'Access, null);
+ Add_Action (Table.States (1190), 97, Reduce, (204, 1), 4,
formal_derived_type_definition_1'Access, null);
+ Table.States (1190).Kernel := To_Vector (((204, 120, 2, False),
(204, 120, 0, False)));
+ Table.States (1190).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 204, 4)));
+ Table.States (1191).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1191), 77, 1237);
+ Table.States (1191).Kernel := To_Vector ((0 => (206, 81, 1,
False)));
+ Table.States (1191).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 1237)));
+ Table.States (1192).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1192), 97, 1238);
+ Table.States (1192).Kernel := To_Vector ((0 => (205, 123, 1,
False)));
+ Table.States (1192).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1238)));
+ Table.States (1193).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (1193), (29, 47, 48, 50, 69, 71, 74,
105), (199, 1), 8,
formal_object_declaration_1'Access, null);
- Table.States (1182).Kernel := To_Vector ((0 => (198, 96, 0,
False)));
- Table.States (1182).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 198, 8)));
- Table.States (1183).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1183), 96, 1228);
- Table.States (1183).Kernel := To_Vector ((0 => (198, 122, 1,
False)));
- Table.States (1183).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1228)));
- Table.States (1184).Action_List.Set_Capacity (46);
- Add_Action (Table.States (1184), (4, 5, 13, 15, 17, 18, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (222, 1), 9, if_statement_1'Access, null);
- Table.States (1184).Kernel := To_Vector ((0 => (222, 96, 0,
False)));
- Table.States (1184).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 222, 9)));
- Table.States (1185).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1185), 96, 1229);
- Table.States (1185).Kernel := To_Vector ((0 => (222, 32, 1,
False)));
- Table.States (1185).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1229)));
- Table.States (1186).Action_List.Set_Capacity (4);
- Add_Action (Table.States (1186), 96, Reduce, (240, 1), 0, null,
null);
- Add_Action (Table.States (1186), 104, 119);
- Add_Action (Table.States (1186), 105, 33);
- Add_Action (Table.States (1186), 106, 34);
- Table.States (1186).Goto_List.Set_Capacity (5);
- Add_Goto (Table.States (1186), 128, 41);
- Add_Goto (Table.States (1186), 239, 632);
- Add_Goto (Table.States (1186), 240, 1230);
- Add_Goto (Table.States (1186), 272, 92);
- Add_Goto (Table.States (1186), 293, 97);
- Table.States (1186).Kernel := To_Vector ((0 => (247, 24, 1,
False)));
- Table.States (1186).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 240, 0)));
- Table.States (1187).Action_List.Set_Capacity (40);
- Add_Action (Table.States (1187), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (247, 1), 9,
+ Table.States (1193).Kernel := To_Vector ((0 => (199, 97, 0,
False)));
+ Table.States (1193).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 199, 8)));
+ Table.States (1194).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1194), 97, 1239);
+ Table.States (1194).Kernel := To_Vector ((0 => (199, 123, 1,
False)));
+ Table.States (1194).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1239)));
+ Table.States (1195).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (1195), (4, 5, 13, 15, 17, 18, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (223, 1), 9, if_statement_1'Access, null);
+ Table.States (1195).Kernel := To_Vector ((0 => (223, 97, 0,
False)));
+ Table.States (1195).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 223, 9)));
+ Table.States (1196).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1196), 97, 1240);
+ Table.States (1196).Kernel := To_Vector ((0 => (223, 32, 1,
False)));
+ Table.States (1196).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1240)));
+ Table.States (1197).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (1197), 79, 31);
+ Add_Action (Table.States (1197), 97, Reduce, (241, 1), 0, null,
null);
+ Add_Action (Table.States (1197), 105, 120);
+ Add_Action (Table.States (1197), 106, 34);
+ Add_Action (Table.States (1197), 107, 35);
+ Table.States (1197).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (1197), 129, 42);
+ Add_Goto (Table.States (1197), 240, 638);
+ Add_Goto (Table.States (1197), 241, 1241);
+ Add_Goto (Table.States (1197), 273, 93);
+ Add_Goto (Table.States (1197), 294, 98);
+ Table.States (1197).Kernel := To_Vector ((0 => (248, 24, 1,
False)));
+ Table.States (1197).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 241, 0)));
+ Table.States (1198).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1198), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (248, 1), 9,
package_body_1'Access, package_body_1_check'Access);
- Table.States (1187).Kernel := To_Vector ((0 => (247, 96, 0,
False)));
- Table.States (1187).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 247, 9)));
- Table.States (1188).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1188), (1 => 96), (251, 0), 9,
package_specification_0'Access,
+ Table.States (1198).Kernel := To_Vector ((0 => (248, 97, 0,
False)));
+ Table.States (1198).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 248, 9)));
+ Table.States (1199).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1199), (1 => 97), (252, 0), 9,
package_specification_0'Access,
package_specification_0_check'Access);
- Table.States (1188).Kernel := To_Vector ((0 => (251, 240, 0,
False)));
- Table.States (1188).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 251, 9)));
- Table.States (1189).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1189), 104, 1231);
- Table.States (1189).Kernel := To_Vector ((0 => (177, 28, 4,
False)));
- Table.States (1189).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 1231)));
- Table.States (1190).Action_List.Set_Capacity (13);
- Add_Action (Table.States (1190), 3, 121);
- Add_Action (Table.States (1190), 35, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (1190), 39, 122);
- Add_Action (Table.States (1190), 40, 123);
- Add_Action (Table.States (1190), 41, 124);
- Add_Action (Table.States (1190), 52, 125);
- Add_Action (Table.States (1190), 76, 126);
- Add_Action (Table.States (1190), 94, 127);
- Add_Action (Table.States (1190), 95, 128);
- Add_Action (Table.States (1190), 103, 129);
- Add_Action (Table.States (1190), 104, 119);
- Add_Action (Table.States (1190), 105, 33);
- Add_Action (Table.States (1190), 106, 34);
- Table.States (1190).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (1190), 117, 130);
- Add_Goto (Table.States (1190), 128, 41);
- Add_Goto (Table.States (1190), 191, 131);
- Add_Goto (Table.States (1190), 192, 1232);
- Add_Goto (Table.States (1190), 197, 133);
- Add_Goto (Table.States (1190), 239, 134);
- Add_Goto (Table.States (1190), 258, 135);
- Add_Goto (Table.States (1190), 272, 92);
- Add_Goto (Table.States (1190), 275, 136);
- Add_Goto (Table.States (1190), 282, 137);
- Add_Goto (Table.States (1190), 283, 138);
- Add_Goto (Table.States (1190), 284, 139);
- Add_Goto (Table.States (1190), 285, 140);
- Add_Goto (Table.States (1190), 286, 141);
- Add_Goto (Table.States (1190), 287, 142);
- Add_Goto (Table.States (1190), 293, 97);
- Add_Goto (Table.States (1190), 301, 143);
- Add_Goto (Table.States (1190), 320, 144);
- Add_Goto (Table.States (1190), 321, 145);
- Add_Goto (Table.States (1190), 330, 146);
- Table.States (1190).Kernel := To_Vector ((0 => (176, 72, 4,
False)));
- Table.States (1190).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (1191).Action_List.Set_Capacity (40);
- Add_Action (Table.States (1191), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (264, 0), 9,
+ Table.States (1199).Kernel := To_Vector ((0 => (252, 241, 0,
False)));
+ Table.States (1199).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 252, 9)));
+ Table.States (1200).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1200), 105, 1242);
+ Table.States (1200).Kernel := To_Vector ((0 => (178, 28, 4,
False)));
+ Table.States (1200).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 1242)));
+ Table.States (1201).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (1201), 3, 122);
+ Add_Action (Table.States (1201), 35, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (1201), 39, 123);
+ Add_Action (Table.States (1201), 40, 124);
+ Add_Action (Table.States (1201), 41, 125);
+ Add_Action (Table.States (1201), 52, 126);
+ Add_Action (Table.States (1201), 76, 127);
+ Add_Action (Table.States (1201), 79, 31);
+ Add_Action (Table.States (1201), 95, 128);
+ Add_Action (Table.States (1201), 96, 129);
+ Add_Action (Table.States (1201), 104, 130);
+ Add_Action (Table.States (1201), 105, 120);
+ Add_Action (Table.States (1201), 106, 34);
+ Add_Action (Table.States (1201), 107, 35);
+ Table.States (1201).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (1201), 118, 131);
+ Add_Goto (Table.States (1201), 129, 42);
+ Add_Goto (Table.States (1201), 192, 132);
+ Add_Goto (Table.States (1201), 193, 1243);
+ Add_Goto (Table.States (1201), 198, 134);
+ Add_Goto (Table.States (1201), 240, 135);
+ Add_Goto (Table.States (1201), 259, 136);
+ Add_Goto (Table.States (1201), 273, 93);
+ Add_Goto (Table.States (1201), 276, 137);
+ Add_Goto (Table.States (1201), 283, 138);
+ Add_Goto (Table.States (1201), 284, 139);
+ Add_Goto (Table.States (1201), 285, 140);
+ Add_Goto (Table.States (1201), 286, 141);
+ Add_Goto (Table.States (1201), 287, 142);
+ Add_Goto (Table.States (1201), 288, 143);
+ Add_Goto (Table.States (1201), 294, 98);
+ Add_Goto (Table.States (1201), 302, 144);
+ Add_Goto (Table.States (1201), 321, 145);
+ Add_Goto (Table.States (1201), 322, 146);
+ Add_Goto (Table.States (1201), 331, 147);
+ Table.States (1201).Kernel := To_Vector ((0 => (177, 72, 4,
False)));
+ Table.States (1201).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (1202).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1202), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (265, 0), 9,
protected_body_0'Access, protected_body_0_check'Access);
- Table.States (1191).Kernel := To_Vector ((0 => (264, 96, 0,
False)));
- Table.States (1191).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 264, 9)));
- Table.States (1192).Action_List.Set_Capacity (17);
- Add_Action (Table.States (1192), 24, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (1192), 25, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (1192), 28, 183);
- Add_Action (Table.States (1192), 29, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (1192), 30, 8);
- Add_Action (Table.States (1192), 40, 12);
- Add_Action (Table.States (1192), 46, 14);
- Add_Action (Table.States (1192), 47, 15);
- Add_Action (Table.States (1192), 48, 16);
- Add_Action (Table.States (1192), 49, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (1192), 50, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (1192), 51, 19);
- Add_Action (Table.States (1192), 63, 25);
- Add_Action (Table.States (1192), 66, 26);
- Add_Action (Table.States (1192), 69, 27);
- Add_Action (Table.States (1192), 71, 28);
- Add_Action (Table.States (1192), 104, 185);
- Table.States (1192).Goto_List.Set_Capacity (54);
- Add_Goto (Table.States (1192), 112, 35);
- Add_Goto (Table.States (1192), 121, 37);
- Add_Goto (Table.States (1192), 127, 40);
- Add_Goto (Table.States (1192), 134, 45);
- Add_Goto (Table.States (1192), 135, 46);
- Add_Goto (Table.States (1192), 157, 391);
- Add_Goto (Table.States (1192), 158, 392);
- Add_Goto (Table.States (1192), 159, 669);
- Add_Goto (Table.States (1192), 179, 54);
- Add_Goto (Table.States (1192), 182, 55);
- Add_Goto (Table.States (1192), 186, 56);
- Add_Goto (Table.States (1192), 193, 58);
- Add_Goto (Table.States (1192), 206, 60);
- Add_Goto (Table.States (1192), 207, 61);
- Add_Goto (Table.States (1192), 209, 62);
- Add_Goto (Table.States (1192), 210, 63);
- Add_Goto (Table.States (1192), 213, 64);
- Add_Goto (Table.States (1192), 214, 65);
- Add_Goto (Table.States (1192), 215, 66);
- Add_Goto (Table.States (1192), 216, 67);
- Add_Goto (Table.States (1192), 219, 69);
- Add_Goto (Table.States (1192), 223, 71);
- Add_Goto (Table.States (1192), 243, 74);
- Add_Goto (Table.States (1192), 244, 75);
- Add_Goto (Table.States (1192), 245, 76);
- Add_Goto (Table.States (1192), 246, 77);
- Add_Goto (Table.States (1192), 247, 78);
- Add_Goto (Table.States (1192), 248, 79);
- Add_Goto (Table.States (1192), 249, 80);
- Add_Goto (Table.States (1192), 250, 81);
- Add_Goto (Table.States (1192), 251, 82);
- Add_Goto (Table.States (1192), 257, 394);
- Add_Goto (Table.States (1192), 259, 84);
- Add_Goto (Table.States (1192), 260, 85);
- Add_Goto (Table.States (1192), 262, 87);
- Add_Goto (Table.States (1192), 263, 88);
- Add_Goto (Table.States (1192), 264, 89);
- Add_Goto (Table.States (1192), 265, 90);
- Add_Goto (Table.States (1192), 266, 1233);
- Add_Goto (Table.States (1192), 271, 91);
- Add_Goto (Table.States (1192), 281, 94);
- Add_Goto (Table.States (1192), 289, 95);
- Add_Goto (Table.States (1192), 304, 102);
- Add_Goto (Table.States (1192), 305, 103);
- Add_Goto (Table.States (1192), 307, 105);
- Add_Goto (Table.States (1192), 308, 106);
- Add_Goto (Table.States (1192), 309, 107);
- Add_Goto (Table.States (1192), 311, 108);
- Add_Goto (Table.States (1192), 313, 109);
- Add_Goto (Table.States (1192), 316, 111);
- Add_Goto (Table.States (1192), 317, 112);
- Add_Goto (Table.States (1192), 319, 113);
- Add_Goto (Table.States (1192), 325, 115);
- Add_Goto (Table.States (1192), 331, 116);
- Table.States (1192).Kernel := To_Vector ((0 => (271, 74, 2,
False)));
- Table.States (1192).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 159, 0)));
- end Subr_19;
- procedure Subr_20
- is begin
- Table.States (1193).Action_List.Set_Capacity (40);
- Add_Action (Table.States (1193), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (304, 0), 9,
+ Table.States (1202).Kernel := To_Vector ((0 => (265, 97, 0,
False)));
+ Table.States (1202).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 265, 9)));
+ Table.States (1203).Action_List.Set_Capacity (17);
+ Add_Action (Table.States (1203), 24, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (1203), 25, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (1203), 28, 184);
+ Add_Action (Table.States (1203), 29, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (1203), 30, 8);
+ Add_Action (Table.States (1203), 40, 12);
+ Add_Action (Table.States (1203), 46, 14);
+ Add_Action (Table.States (1203), 47, 15);
+ Add_Action (Table.States (1203), 48, 16);
+ Add_Action (Table.States (1203), 49, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (1203), 50, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (1203), 51, 19);
+ Add_Action (Table.States (1203), 63, 25);
+ Add_Action (Table.States (1203), 66, 26);
+ Add_Action (Table.States (1203), 69, 27);
+ Add_Action (Table.States (1203), 71, 28);
+ Add_Action (Table.States (1203), 105, 186);
+ Table.States (1203).Goto_List.Set_Capacity (54);
+ Add_Goto (Table.States (1203), 113, 36);
+ Add_Goto (Table.States (1203), 122, 38);
+ Add_Goto (Table.States (1203), 128, 41);
+ Add_Goto (Table.States (1203), 135, 46);
+ Add_Goto (Table.States (1203), 136, 47);
+ Add_Goto (Table.States (1203), 158, 392);
+ Add_Goto (Table.States (1203), 159, 393);
+ Add_Goto (Table.States (1203), 160, 675);
+ Add_Goto (Table.States (1203), 180, 55);
+ Add_Goto (Table.States (1203), 183, 56);
+ Add_Goto (Table.States (1203), 187, 57);
+ Add_Goto (Table.States (1203), 194, 59);
+ Add_Goto (Table.States (1203), 207, 61);
+ Add_Goto (Table.States (1203), 208, 62);
+ Add_Goto (Table.States (1203), 210, 63);
+ Add_Goto (Table.States (1203), 211, 64);
+ Add_Goto (Table.States (1203), 214, 65);
+ Add_Goto (Table.States (1203), 215, 66);
+ Add_Goto (Table.States (1203), 216, 67);
+ Add_Goto (Table.States (1203), 217, 68);
+ Add_Goto (Table.States (1203), 220, 70);
+ Add_Goto (Table.States (1203), 224, 72);
+ Add_Goto (Table.States (1203), 244, 75);
+ Add_Goto (Table.States (1203), 245, 76);
+ Add_Goto (Table.States (1203), 246, 77);
+ Add_Goto (Table.States (1203), 247, 78);
+ Add_Goto (Table.States (1203), 248, 79);
+ Add_Goto (Table.States (1203), 249, 80);
+ Add_Goto (Table.States (1203), 250, 81);
+ Add_Goto (Table.States (1203), 251, 82);
+ Add_Goto (Table.States (1203), 252, 83);
+ Add_Goto (Table.States (1203), 258, 395);
+ Add_Goto (Table.States (1203), 260, 85);
+ Add_Goto (Table.States (1203), 261, 86);
+ Add_Goto (Table.States (1203), 263, 88);
+ Add_Goto (Table.States (1203), 264, 89);
+ Add_Goto (Table.States (1203), 265, 90);
+ Add_Goto (Table.States (1203), 266, 91);
+ Add_Goto (Table.States (1203), 267, 1244);
+ Add_Goto (Table.States (1203), 272, 92);
+ Add_Goto (Table.States (1203), 282, 95);
+ Add_Goto (Table.States (1203), 290, 96);
+ Add_Goto (Table.States (1203), 305, 103);
+ Add_Goto (Table.States (1203), 306, 104);
+ Add_Goto (Table.States (1203), 308, 106);
+ Add_Goto (Table.States (1203), 309, 107);
+ Add_Goto (Table.States (1203), 310, 108);
+ Add_Goto (Table.States (1203), 312, 109);
+ Add_Goto (Table.States (1203), 314, 110);
+ Add_Goto (Table.States (1203), 317, 112);
+ Add_Goto (Table.States (1203), 318, 113);
+ Add_Goto (Table.States (1203), 320, 114);
+ Add_Goto (Table.States (1203), 326, 116);
+ Add_Goto (Table.States (1203), 332, 117);
+ Table.States (1203).Kernel := To_Vector ((0 => (272, 74, 2,
False)));
+ Table.States (1203).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 160, 0)));
+ Table.States (1204).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1204), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (305, 0), 9,
single_protected_declaration_0'Access,
single_protected_declaration_0_check'Access);
- Table.States (1193).Kernel := To_Vector ((0 => (304, 96, 0,
False)));
- Table.States (1193).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 304, 9)));
- Table.States (1194).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1194), (1 => 96), (266, 0), 5,
protected_definition_0'Access,
+ Table.States (1204).Kernel := To_Vector ((0 => (305, 97, 0,
False)));
+ Table.States (1204).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 305, 9)));
+ Table.States (1205).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1205), (1 => 97), (267, 0), 5,
protected_definition_0'Access,
protected_definition_0_check'Access);
- Table.States (1194).Kernel := To_Vector ((0 => (266, 220, 0,
False)));
- Table.States (1194).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 266, 5)));
- Table.States (1195).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1195), 96, Reduce, (220, 1), 0, null,
null);
- Add_Action (Table.States (1195), 104, 149);
- Table.States (1195).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (1195), 220, 1234);
- Table.States (1195).Kernel := To_Vector ((0 => (316, 24, 1,
False)));
- Table.States (1195).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 220, 0)));
- Table.States (1196).Action_List.Set_Capacity (17);
- Add_Action (Table.States (1196), 24, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (1196), 25, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (1196), 28, 183);
- Add_Action (Table.States (1196), 29, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (1196), 30, 8);
- Add_Action (Table.States (1196), 40, 12);
- Add_Action (Table.States (1196), 46, 14);
- Add_Action (Table.States (1196), 47, 15);
- Add_Action (Table.States (1196), 48, 16);
- Add_Action (Table.States (1196), 49, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (1196), 50, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (1196), 51, 19);
- Add_Action (Table.States (1196), 63, 25);
- Add_Action (Table.States (1196), 66, 26);
- Add_Action (Table.States (1196), 69, 27);
- Add_Action (Table.States (1196), 71, 28);
- Add_Action (Table.States (1196), 104, 185);
- Table.States (1196).Goto_List.Set_Capacity (54);
- Add_Goto (Table.States (1196), 112, 35);
- Add_Goto (Table.States (1196), 121, 37);
- Add_Goto (Table.States (1196), 127, 40);
- Add_Goto (Table.States (1196), 134, 45);
- Add_Goto (Table.States (1196), 135, 46);
- Add_Goto (Table.States (1196), 157, 391);
- Add_Goto (Table.States (1196), 158, 392);
- Add_Goto (Table.States (1196), 159, 694);
- Add_Goto (Table.States (1196), 179, 54);
- Add_Goto (Table.States (1196), 182, 55);
- Add_Goto (Table.States (1196), 186, 56);
- Add_Goto (Table.States (1196), 193, 58);
- Add_Goto (Table.States (1196), 206, 60);
- Add_Goto (Table.States (1196), 207, 61);
- Add_Goto (Table.States (1196), 209, 62);
- Add_Goto (Table.States (1196), 210, 63);
- Add_Goto (Table.States (1196), 213, 64);
- Add_Goto (Table.States (1196), 214, 65);
- Add_Goto (Table.States (1196), 215, 66);
- Add_Goto (Table.States (1196), 216, 67);
- Add_Goto (Table.States (1196), 219, 69);
- Add_Goto (Table.States (1196), 223, 71);
- Add_Goto (Table.States (1196), 243, 74);
- Add_Goto (Table.States (1196), 244, 75);
- Add_Goto (Table.States (1196), 245, 76);
- Add_Goto (Table.States (1196), 246, 77);
- Add_Goto (Table.States (1196), 247, 78);
- Add_Goto (Table.States (1196), 248, 79);
- Add_Goto (Table.States (1196), 249, 80);
- Add_Goto (Table.States (1196), 250, 81);
- Add_Goto (Table.States (1196), 251, 82);
- Add_Goto (Table.States (1196), 257, 394);
- Add_Goto (Table.States (1196), 259, 84);
- Add_Goto (Table.States (1196), 260, 85);
- Add_Goto (Table.States (1196), 262, 87);
- Add_Goto (Table.States (1196), 263, 88);
- Add_Goto (Table.States (1196), 264, 89);
- Add_Goto (Table.States (1196), 265, 90);
- Add_Goto (Table.States (1196), 271, 91);
- Add_Goto (Table.States (1196), 281, 94);
- Add_Goto (Table.States (1196), 289, 95);
- Add_Goto (Table.States (1196), 304, 102);
- Add_Goto (Table.States (1196), 305, 103);
- Add_Goto (Table.States (1196), 307, 105);
- Add_Goto (Table.States (1196), 308, 106);
- Add_Goto (Table.States (1196), 309, 107);
- Add_Goto (Table.States (1196), 311, 108);
- Add_Goto (Table.States (1196), 313, 109);
- Add_Goto (Table.States (1196), 316, 111);
- Add_Goto (Table.States (1196), 317, 112);
- Add_Goto (Table.States (1196), 318, 1235);
- Add_Goto (Table.States (1196), 319, 113);
- Add_Goto (Table.States (1196), 325, 115);
- Add_Goto (Table.States (1196), 331, 116);
- Table.States (1196).Kernel := To_Vector ((0 => (319, 74, 2,
False)));
- Table.States (1196).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 318, 0)));
- Table.States (1197).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1197), 96, 1236);
- Table.States (1197).Kernel := To_Vector ((0 => (319, 220, 1,
False)));
- Table.States (1197).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1236)));
- Table.States (1198).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1198), 96, Reduce, (220, 1), 0, null,
null);
- Add_Action (Table.States (1198), 104, 149);
- Table.States (1198).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (1198), 220, 1237);
- Table.States (1198).Kernel := To_Vector ((0 => (305, 24, 1,
False)));
- Table.States (1198).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 220, 0)));
- Table.States (1199).Action_List.Set_Capacity (6);
- Add_Action (Table.States (1199), 7, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (1199), 8, 1144);
- Add_Action (Table.States (1199), 40, 744);
- Add_Action (Table.States (1199), 104, 119);
- Add_Action (Table.States (1199), 105, 33);
- Add_Action (Table.States (1199), 106, 34);
- Table.States (1199).Goto_List.Set_Capacity (8);
- Add_Goto (Table.States (1199), 114, 1145);
- Add_Goto (Table.States (1199), 128, 41);
- Add_Goto (Table.States (1199), 147, 1238);
- Add_Goto (Table.States (1199), 239, 484);
- Add_Goto (Table.States (1199), 241, 723);
- Add_Goto (Table.States (1199), 272, 92);
- Add_Goto (Table.States (1199), 293, 97);
- Add_Goto (Table.States (1199), 314, 1147);
- Table.States (1199).Kernel := To_Vector ((0 => (120, 42, 1,
False)));
- Table.States (1199).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (1200).Action_List.Set_Capacity (6);
- Add_Action (Table.States (1200), 7, Reduce, (241, 1), 0, null,
null);
- Add_Action (Table.States (1200), 8, 1144);
- Add_Action (Table.States (1200), 40, 744);
- Add_Action (Table.States (1200), 104, 119);
- Add_Action (Table.States (1200), 105, 33);
- Add_Action (Table.States (1200), 106, 34);
- Table.States (1200).Goto_List.Set_Capacity (8);
- Add_Goto (Table.States (1200), 114, 1145);
- Add_Goto (Table.States (1200), 128, 41);
- Add_Goto (Table.States (1200), 147, 1239);
- Add_Goto (Table.States (1200), 239, 484);
- Add_Goto (Table.States (1200), 241, 723);
- Add_Goto (Table.States (1200), 272, 92);
- Add_Goto (Table.States (1200), 293, 97);
- Add_Goto (Table.States (1200), 314, 1147);
- Table.States (1200).Kernel := To_Vector ((0 => (120, 42, 1,
False)));
- Table.States (1200).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (1201).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1201), (77, 83), (226, 0), 3, null,
null);
- Table.States (1201).Kernel := To_Vector ((0 => (226, 225, 0,
True)));
- Table.States (1201).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 226, 3)));
- Table.States (1201).Minimal_Complete_Actions_Recursive := True;
- Table.States (1202).Action_List.Set_Capacity (5);
- Add_Action (Table.States (1202), 53, 1240);
- Add_Action (Table.States (1202), 76, 235);
- Add_Action (Table.States (1202), 84, 237);
- Add_Action (Table.States (1202), 101, 239);
- Add_Action (Table.States (1202), 102, 240);
- Table.States (1202).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (1202), 115, 241);
- Add_Goto (Table.States (1202), 322, 242);
- Table.States (1202).Kernel := To_Vector (((128, 239, 2, True),
(225, 239, 2, False), (239, 239, 5, True),
- (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True),
- (293, 239, 2, True)));
- Table.States (1202).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 53, 1240)));
- Table.States (1203).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1203), (77, 83), (225, 0), 3, null,
null);
- Table.States (1203).Kernel := To_Vector ((0 => (225, 80, 0,
False)));
- Table.States (1203).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 225, 3)));
- Table.States (1204).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1204), (74, 96), (326, 4), 5, null,
null);
- Table.States (1204).Kernel := To_Vector ((0 => (326, 279, 0,
False)));
- Table.States (1204).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 326, 5)));
- Table.States (1205).Action_List.Set_Capacity (11);
- Add_Action (Table.States (1205), 3, 121);
- Add_Action (Table.States (1205), 39, 122);
- Add_Action (Table.States (1205), 40, 123);
- Add_Action (Table.States (1205), 41, 124);
- Add_Action (Table.States (1205), 76, 126);
- Add_Action (Table.States (1205), 94, 127);
- Add_Action (Table.States (1205), 95, 128);
- Add_Action (Table.States (1205), 103, 129);
- Add_Action (Table.States (1205), 104, 119);
- Add_Action (Table.States (1205), 105, 33);
- Add_Action (Table.States (1205), 106, 34);
- Table.States (1205).Goto_List.Set_Capacity (11);
- Add_Goto (Table.States (1205), 117, 130);
- Add_Goto (Table.States (1205), 128, 41);
- Add_Goto (Table.States (1205), 197, 133);
- Add_Goto (Table.States (1205), 239, 134);
- Add_Goto (Table.States (1205), 258, 135);
- Add_Goto (Table.States (1205), 272, 92);
- Add_Goto (Table.States (1205), 293, 97);
- Add_Goto (Table.States (1205), 301, 1241);
- Add_Goto (Table.States (1205), 320, 144);
- Add_Goto (Table.States (1205), 321, 145);
- Add_Goto (Table.States (1205), 330, 146);
- Table.States (1205).Kernel := To_Vector ((0 => (279, 85, 1,
False)));
- Table.States (1205).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
- Table.States (1206).Action_List.Set_Capacity (15);
- Add_Action (Table.States (1206), 3, 121);
- Add_Action (Table.States (1206), 39, 122);
- Add_Action (Table.States (1206), 40, 261);
- Add_Action (Table.States (1206), 41, 124);
- Add_Action (Table.States (1206), 44, 263);
- Add_Action (Table.States (1206), 52, 125);
- Add_Action (Table.States (1206), 76, 126);
- Add_Action (Table.States (1206), 79, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (1206), 87, Reduce, (166, 2), 0, null,
null);
- Add_Action (Table.States (1206), 94, 127);
- Add_Action (Table.States (1206), 95, 128);
- Add_Action (Table.States (1206), 103, 129);
- Add_Action (Table.States (1206), 104, 119);
- Add_Action (Table.States (1206), 105, 33);
- Add_Action (Table.States (1206), 106, 34);
- Table.States (1206).Goto_List.Set_Capacity (22);
- Add_Goto (Table.States (1206), 117, 130);
- Add_Goto (Table.States (1206), 128, 41);
- Add_Goto (Table.States (1206), 165, 269);
- Add_Goto (Table.States (1206), 166, 1242);
- Add_Goto (Table.States (1206), 191, 601);
- Add_Goto (Table.States (1206), 197, 133);
- Add_Goto (Table.States (1206), 239, 274);
- Add_Goto (Table.States (1206), 258, 135);
- Add_Goto (Table.States (1206), 272, 92);
- Add_Goto (Table.States (1206), 275, 136);
- Add_Goto (Table.States (1206), 277, 276);
- Add_Goto (Table.States (1206), 282, 137);
- Add_Goto (Table.States (1206), 283, 138);
- Add_Goto (Table.States (1206), 284, 139);
- Add_Goto (Table.States (1206), 285, 140);
- Add_Goto (Table.States (1206), 286, 141);
- Add_Goto (Table.States (1206), 287, 142);
- Add_Goto (Table.States (1206), 293, 97);
- Add_Goto (Table.States (1206), 301, 277);
- Add_Goto (Table.States (1206), 320, 144);
- Add_Goto (Table.States (1206), 321, 145);
- Add_Goto (Table.States (1206), 330, 146);
- Table.States (1206).Kernel := To_Vector ((0 => (329, 72, 1,
False)));
- Table.States (1206).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 166, 0)));
- Table.States (1207).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1207), 24, 1243);
- Add_Action (Table.States (1207), 72, 1206);
- Table.States (1207).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (1207), 329, 1244);
- Table.States (1207).Kernel := To_Vector (((327, 328, 3, False),
(328, 328, 2, True)));
- Table.States (1207).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1243)));
- Table.States (1208).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1208), (24, 72), (328, 1), 1, null,
null);
- Table.States (1208).Kernel := To_Vector ((0 => (328, 329, 0,
False)));
- Table.States (1208).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 328, 1)));
- Table.States (1209).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1209), (74, 82, 96), (147, 2), 2, null,
null);
- Table.States (1209).Kernel := To_Vector ((0 => (147, 114, 0,
False)));
- Table.States (1209).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 147, 2)));
- Table.States (1210).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1210), (74, 82, 96), (147, 0), 2, null,
null);
- Table.States (1210).Kernel := To_Vector ((0 => (147, 314, 0,
False)));
- Table.States (1210).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 147, 2)));
- Table.States (1211).Action_List.Set_Capacity (14);
- Add_Action (Table.States (1211), 3, 121);
- Add_Action (Table.States (1211), 39, 122);
- Add_Action (Table.States (1211), 40, 123);
- Add_Action (Table.States (1211), 41, 124);
- Add_Action (Table.States (1211), 52, 125);
- Add_Action (Table.States (1211), 74, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (1211), 76, 126);
- Add_Action (Table.States (1211), 94, 127);
- Add_Action (Table.States (1211), 95, 128);
- Add_Action (Table.States (1211), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (1211), 103, 129);
- Add_Action (Table.States (1211), 104, 119);
- Add_Action (Table.States (1211), 105, 33);
+ Table.States (1205).Kernel := To_Vector ((0 => (267, 221, 0,
False)));
+ Table.States (1205).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 267, 5)));
+ Table.States (1206).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1206), 97, Reduce, (221, 1), 0, null,
null);
+ Add_Action (Table.States (1206), 105, 150);
+ Table.States (1206).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (1206), 221, 1245);
+ Table.States (1206).Kernel := To_Vector ((0 => (317, 24, 1,
False)));
+ Table.States (1206).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 221, 0)));
+ Table.States (1207).Action_List.Set_Capacity (17);
+ Add_Action (Table.States (1207), 24, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (1207), 25, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (1207), 28, 184);
+ Add_Action (Table.States (1207), 29, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (1207), 30, 8);
+ Add_Action (Table.States (1207), 40, 12);
+ Add_Action (Table.States (1207), 46, 14);
+ Add_Action (Table.States (1207), 47, 15);
+ Add_Action (Table.States (1207), 48, 16);
+ Add_Action (Table.States (1207), 49, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (1207), 50, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (1207), 51, 19);
+ Add_Action (Table.States (1207), 63, 25);
+ Add_Action (Table.States (1207), 66, 26);
+ Add_Action (Table.States (1207), 69, 27);
+ Add_Action (Table.States (1207), 71, 28);
+ Add_Action (Table.States (1207), 105, 186);
+ Table.States (1207).Goto_List.Set_Capacity (54);
+ Add_Goto (Table.States (1207), 113, 36);
+ Add_Goto (Table.States (1207), 122, 38);
+ Add_Goto (Table.States (1207), 128, 41);
+ Add_Goto (Table.States (1207), 135, 46);
+ Add_Goto (Table.States (1207), 136, 47);
+ Add_Goto (Table.States (1207), 158, 392);
+ Add_Goto (Table.States (1207), 159, 393);
+ Add_Goto (Table.States (1207), 160, 700);
+ Add_Goto (Table.States (1207), 180, 55);
+ Add_Goto (Table.States (1207), 183, 56);
+ Add_Goto (Table.States (1207), 187, 57);
+ Add_Goto (Table.States (1207), 194, 59);
+ Add_Goto (Table.States (1207), 207, 61);
+ Add_Goto (Table.States (1207), 208, 62);
+ Add_Goto (Table.States (1207), 210, 63);
+ Add_Goto (Table.States (1207), 211, 64);
+ Add_Goto (Table.States (1207), 214, 65);
+ Add_Goto (Table.States (1207), 215, 66);
+ Add_Goto (Table.States (1207), 216, 67);
+ Add_Goto (Table.States (1207), 217, 68);
+ Add_Goto (Table.States (1207), 220, 70);
+ Add_Goto (Table.States (1207), 224, 72);
+ Add_Goto (Table.States (1207), 244, 75);
+ Add_Goto (Table.States (1207), 245, 76);
+ Add_Goto (Table.States (1207), 246, 77);
+ Add_Goto (Table.States (1207), 247, 78);
+ Add_Goto (Table.States (1207), 248, 79);
+ Add_Goto (Table.States (1207), 249, 80);
+ Add_Goto (Table.States (1207), 250, 81);
+ Add_Goto (Table.States (1207), 251, 82);
+ Add_Goto (Table.States (1207), 252, 83);
+ Add_Goto (Table.States (1207), 258, 395);
+ Add_Goto (Table.States (1207), 260, 85);
+ Add_Goto (Table.States (1207), 261, 86);
+ Add_Goto (Table.States (1207), 263, 88);
+ Add_Goto (Table.States (1207), 264, 89);
+ Add_Goto (Table.States (1207), 265, 90);
+ Add_Goto (Table.States (1207), 266, 91);
+ Add_Goto (Table.States (1207), 272, 92);
+ Add_Goto (Table.States (1207), 282, 95);
+ Add_Goto (Table.States (1207), 290, 96);
+ Add_Goto (Table.States (1207), 305, 103);
+ Add_Goto (Table.States (1207), 306, 104);
+ Add_Goto (Table.States (1207), 308, 106);
+ Add_Goto (Table.States (1207), 309, 107);
+ Add_Goto (Table.States (1207), 310, 108);
+ Add_Goto (Table.States (1207), 312, 109);
+ Add_Goto (Table.States (1207), 314, 110);
+ Add_Goto (Table.States (1207), 317, 112);
+ Add_Goto (Table.States (1207), 318, 113);
+ Add_Goto (Table.States (1207), 319, 1246);
+ Add_Goto (Table.States (1207), 320, 114);
+ Add_Goto (Table.States (1207), 326, 116);
+ Add_Goto (Table.States (1207), 332, 117);
+ Table.States (1207).Kernel := To_Vector ((0 => (320, 74, 2,
False)));
+ Table.States (1207).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 319, 0)));
+ Table.States (1208).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1208), 97, 1247);
+ Table.States (1208).Kernel := To_Vector ((0 => (320, 221, 1,
False)));
+ Table.States (1208).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1247)));
+ Table.States (1209).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1209), 97, Reduce, (221, 1), 0, null,
null);
+ Add_Action (Table.States (1209), 105, 150);
+ Table.States (1209).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (1209), 221, 1248);
+ Table.States (1209).Kernel := To_Vector ((0 => (306, 24, 1,
False)));
+ Table.States (1209).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 221, 0)));
+ Table.States (1210).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (1210), 7, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (1210), 8, 1155);
+ Add_Action (Table.States (1210), 40, 750);
+ Add_Action (Table.States (1210), 79, 31);
+ Add_Action (Table.States (1210), 105, 120);
+ Add_Action (Table.States (1210), 106, 34);
+ Add_Action (Table.States (1210), 107, 35);
+ Table.States (1210).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (1210), 115, 1156);
+ Add_Goto (Table.States (1210), 129, 42);
+ Add_Goto (Table.States (1210), 148, 1249);
+ Add_Goto (Table.States (1210), 240, 487);
+ Add_Goto (Table.States (1210), 242, 729);
+ Add_Goto (Table.States (1210), 273, 93);
+ Add_Goto (Table.States (1210), 294, 98);
+ Add_Goto (Table.States (1210), 315, 1158);
+ Table.States (1210).Kernel := To_Vector ((0 => (121, 42, 1,
False)));
+ Table.States (1210).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (1211).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (1211), 7, Reduce, (242, 1), 0, null,
null);
+ Add_Action (Table.States (1211), 8, 1155);
+ Add_Action (Table.States (1211), 40, 750);
+ Add_Action (Table.States (1211), 79, 31);
+ Add_Action (Table.States (1211), 105, 120);
Add_Action (Table.States (1211), 106, 34);
- Table.States (1211).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (1211), 117, 130);
- Add_Goto (Table.States (1211), 128, 41);
- Add_Goto (Table.States (1211), 191, 131);
- Add_Goto (Table.States (1211), 192, 1245);
- Add_Goto (Table.States (1211), 197, 133);
- Add_Goto (Table.States (1211), 239, 134);
- Add_Goto (Table.States (1211), 258, 135);
- Add_Goto (Table.States (1211), 272, 92);
- Add_Goto (Table.States (1211), 275, 136);
- Add_Goto (Table.States (1211), 282, 137);
- Add_Goto (Table.States (1211), 283, 138);
- Add_Goto (Table.States (1211), 284, 139);
- Add_Goto (Table.States (1211), 285, 140);
- Add_Goto (Table.States (1211), 286, 141);
- Add_Goto (Table.States (1211), 287, 142);
- Add_Goto (Table.States (1211), 293, 97);
- Add_Goto (Table.States (1211), 301, 143);
- Add_Goto (Table.States (1211), 320, 144);
- Add_Goto (Table.States (1211), 321, 145);
- Add_Goto (Table.States (1211), 330, 146);
- Table.States (1211).Kernel := To_Vector ((0 => (146, 82, 1,
False)));
- Table.States (1211).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (1212).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1212), 96, 1246);
- Table.States (1212).Kernel := To_Vector ((0 => (146, 122, 1,
False)));
- Table.States (1212).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1246)));
- Table.States (1213).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1213), 10, 1006);
- Add_Action (Table.States (1213), 74, Reduce, (119, 0), 2, null,
null);
- Add_Action (Table.States (1213), 96, Reduce, (119, 0), 2, null,
null);
- Table.States (1213).Kernel := To_Vector (((119, 227, 0, False),
(227, 227, 2, True)));
- Table.States (1213).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 119, 2)));
- Table.States (1214).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1214), 49, 1247);
- Table.States (1214).Kernel := To_Vector ((0 => (259, 74, 2,
False)));
- Table.States (1214).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 49, 1247)));
+ Add_Action (Table.States (1211), 107, 35);
+ Table.States (1211).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (1211), 115, 1156);
+ Add_Goto (Table.States (1211), 129, 42);
+ Add_Goto (Table.States (1211), 148, 1250);
+ Add_Goto (Table.States (1211), 240, 487);
+ Add_Goto (Table.States (1211), 242, 729);
+ Add_Goto (Table.States (1211), 273, 93);
+ Add_Goto (Table.States (1211), 294, 98);
+ Add_Goto (Table.States (1211), 315, 1158);
+ Table.States (1211).Kernel := To_Vector ((0 => (121, 42, 1,
False)));
+ Table.States (1211).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (1212).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1212), (77, 84), (227, 0), 3, null,
null);
+ Table.States (1212).Kernel := To_Vector ((0 => (227, 226, 0,
True)));
+ Table.States (1212).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 227, 3)));
+ Table.States (1212).Minimal_Complete_Actions_Recursive := True;
+ Table.States (1213).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (1213), 53, 1251);
+ Add_Action (Table.States (1213), 76, 236);
+ Add_Action (Table.States (1213), 85, 238);
+ Add_Action (Table.States (1213), 102, 240);
+ Add_Action (Table.States (1213), 103, 241);
+ Table.States (1213).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (1213), 116, 242);
+ Add_Goto (Table.States (1213), 323, 243);
+ Table.States (1213).Kernel := To_Vector (((129, 240, 2, True),
(226, 240, 2, False), (240, 240, 5, True),
+ (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True),
(294, 240, 2, True), (294, 240, 2, True),
+ (294, 240, 2, True)));
+ Table.States (1213).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 53, 1251)));
+ end Subr_20;
+ procedure Subr_21
+ is begin
+ Table.States (1214).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1214), (77, 84), (226, 0), 3, null,
null);
+ Table.States (1214).Kernel := To_Vector ((0 => (226, 81, 0,
False)));
+ Table.States (1214).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 226, 3)));
Table.States (1215).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1215), 41, 707);
- Add_Action (Table.States (1215), 54, 710);
- Table.States (1215).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (1215), 280, 1248);
- Table.States (1215).Kernel := To_Vector ((0 => (162, 74, 2,
False)));
- Table.States (1215).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 41, 707)));
- Table.States (1216).Action_List.Set_Capacity (24);
- Add_Action (Table.States (1216), 4, 1);
- Add_Action (Table.States (1216), 5, 2);
- Add_Action (Table.States (1216), 13, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (1216), 15, 3);
- Add_Action (Table.States (1216), 17, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (1216), 18, 4);
- Add_Action (Table.States (1216), 24, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (1216), 27, 5);
- Add_Action (Table.States (1216), 28, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (1216), 31, 9);
- Add_Action (Table.States (1216), 32, 10);
- Add_Action (Table.States (1216), 37, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (1216), 41, 13);
- Add_Action (Table.States (1216), 48, 16);
- Add_Action (Table.States (1216), 52, 20);
- Add_Action (Table.States (1216), 57, 21);
- Add_Action (Table.States (1216), 58, 22);
- Add_Action (Table.States (1216), 61, 24);
- Add_Action (Table.States (1216), 72, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (1216), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (1216), 93, 31);
- Add_Action (Table.States (1216), 104, 360);
- Add_Action (Table.States (1216), 105, 33);
+ Add_Action (Table.States (1215), (74, 97), (327, 4), 5, null,
null);
+ Table.States (1215).Kernel := To_Vector ((0 => (327, 280, 0,
False)));
+ Table.States (1215).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 327, 5)));
+ Table.States (1216).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (1216), 3, 122);
+ Add_Action (Table.States (1216), 39, 123);
+ Add_Action (Table.States (1216), 40, 124);
+ Add_Action (Table.States (1216), 41, 125);
+ Add_Action (Table.States (1216), 76, 127);
+ Add_Action (Table.States (1216), 79, 31);
+ Add_Action (Table.States (1216), 95, 128);
+ Add_Action (Table.States (1216), 96, 129);
+ Add_Action (Table.States (1216), 104, 130);
+ Add_Action (Table.States (1216), 105, 120);
Add_Action (Table.States (1216), 106, 34);
- Table.States (1216).Goto_List.Set_Capacity (31);
- Add_Goto (Table.States (1216), 113, 36);
- Add_Goto (Table.States (1216), 123, 38);
- Add_Goto (Table.States (1216), 126, 39);
- Add_Goto (Table.States (1216), 128, 41);
- Add_Goto (Table.States (1216), 131, 42);
- Add_Goto (Table.States (1216), 132, 43);
- Add_Goto (Table.States (1216), 133, 44);
- Add_Goto (Table.States (1216), 139, 47);
- Add_Goto (Table.States (1216), 151, 50);
- Add_Goto (Table.States (1216), 152, 51);
- Add_Goto (Table.States (1216), 161, 53);
- Add_Goto (Table.States (1216), 190, 57);
- Add_Goto (Table.States (1216), 196, 59);
- Add_Goto (Table.States (1216), 217, 68);
- Add_Goto (Table.States (1216), 222, 70);
- Add_Goto (Table.States (1216), 232, 72);
- Add_Goto (Table.States (1216), 239, 73);
- Add_Goto (Table.States (1216), 257, 83);
- Add_Goto (Table.States (1216), 261, 86);
- Add_Goto (Table.States (1216), 272, 92);
- Add_Goto (Table.States (1216), 276, 93);
- Add_Goto (Table.States (1216), 290, 96);
- Add_Goto (Table.States (1216), 293, 97);
+ Add_Action (Table.States (1216), 107, 35);
+ Table.States (1216).Goto_List.Set_Capacity (11);
+ Add_Goto (Table.States (1216), 118, 131);
+ Add_Goto (Table.States (1216), 129, 42);
+ Add_Goto (Table.States (1216), 198, 134);
+ Add_Goto (Table.States (1216), 240, 135);
+ Add_Goto (Table.States (1216), 259, 136);
+ Add_Goto (Table.States (1216), 273, 93);
Add_Goto (Table.States (1216), 294, 98);
- Add_Goto (Table.States (1216), 298, 99);
- Add_Goto (Table.States (1216), 299, 361);
- Add_Goto (Table.States (1216), 300, 1249);
- Add_Goto (Table.States (1216), 302, 100);
- Add_Goto (Table.States (1216), 303, 101);
- Add_Goto (Table.States (1216), 306, 363);
- Add_Goto (Table.States (1216), 323, 114);
- Table.States (1216).Kernel := To_Vector ((0 => (187, 87, 0,
False)));
- Table.States (1216).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 300, 0)));
- Table.States (1217).Action_List.Set_Capacity (40);
- Add_Action (Table.States (1217), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (244, 1), 9,
+ Add_Goto (Table.States (1216), 302, 1252);
+ Add_Goto (Table.States (1216), 321, 145);
+ Add_Goto (Table.States (1216), 322, 146);
+ Add_Goto (Table.States (1216), 331, 147);
+ Table.States (1216).Kernel := To_Vector ((0 => (280, 86, 1,
False)));
+ Table.States (1216).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
+ Table.States (1217).Action_List.Set_Capacity (16);
+ Add_Action (Table.States (1217), 3, 122);
+ Add_Action (Table.States (1217), 39, 123);
+ Add_Action (Table.States (1217), 40, 262);
+ Add_Action (Table.States (1217), 41, 125);
+ Add_Action (Table.States (1217), 44, 264);
+ Add_Action (Table.States (1217), 52, 126);
+ Add_Action (Table.States (1217), 76, 127);
+ Add_Action (Table.States (1217), 79, 31);
+ Add_Action (Table.States (1217), 80, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (1217), 88, Reduce, (167, 2), 0, null,
null);
+ Add_Action (Table.States (1217), 95, 128);
+ Add_Action (Table.States (1217), 96, 129);
+ Add_Action (Table.States (1217), 104, 130);
+ Add_Action (Table.States (1217), 105, 120);
+ Add_Action (Table.States (1217), 106, 34);
+ Add_Action (Table.States (1217), 107, 35);
+ Table.States (1217).Goto_List.Set_Capacity (22);
+ Add_Goto (Table.States (1217), 118, 131);
+ Add_Goto (Table.States (1217), 129, 42);
+ Add_Goto (Table.States (1217), 166, 270);
+ Add_Goto (Table.States (1217), 167, 1253);
+ Add_Goto (Table.States (1217), 192, 606);
+ Add_Goto (Table.States (1217), 198, 134);
+ Add_Goto (Table.States (1217), 240, 275);
+ Add_Goto (Table.States (1217), 259, 136);
+ Add_Goto (Table.States (1217), 273, 93);
+ Add_Goto (Table.States (1217), 276, 137);
+ Add_Goto (Table.States (1217), 278, 277);
+ Add_Goto (Table.States (1217), 283, 138);
+ Add_Goto (Table.States (1217), 284, 139);
+ Add_Goto (Table.States (1217), 285, 140);
+ Add_Goto (Table.States (1217), 286, 141);
+ Add_Goto (Table.States (1217), 287, 142);
+ Add_Goto (Table.States (1217), 288, 143);
+ Add_Goto (Table.States (1217), 294, 98);
+ Add_Goto (Table.States (1217), 302, 278);
+ Add_Goto (Table.States (1217), 321, 145);
+ Add_Goto (Table.States (1217), 322, 146);
+ Add_Goto (Table.States (1217), 331, 147);
+ Table.States (1217).Kernel := To_Vector ((0 => (330, 72, 1,
False)));
+ Table.States (1217).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 167, 0)));
+ Table.States (1218).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1218), 24, 1254);
+ Add_Action (Table.States (1218), 72, 1217);
+ Table.States (1218).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (1218), 330, 1255);
+ Table.States (1218).Kernel := To_Vector (((328, 329, 3, False),
(329, 329, 2, True)));
+ Table.States (1218).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1254)));
+ Table.States (1219).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1219), (24, 72), (329, 1), 1, null,
null);
+ Table.States (1219).Kernel := To_Vector ((0 => (329, 330, 0,
False)));
+ Table.States (1219).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 329, 1)));
+ Table.States (1220).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (1220), (74, 83, 97), (148, 2), 2, null,
null);
+ Table.States (1220).Kernel := To_Vector ((0 => (148, 115, 0,
False)));
+ Table.States (1220).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 148, 2)));
+ Table.States (1221).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (1221), (74, 83, 97), (148, 0), 2, null,
null);
+ Table.States (1221).Kernel := To_Vector ((0 => (148, 315, 0,
False)));
+ Table.States (1221).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 148, 2)));
+ Table.States (1222).Action_List.Set_Capacity (15);
+ Add_Action (Table.States (1222), 3, 122);
+ Add_Action (Table.States (1222), 39, 123);
+ Add_Action (Table.States (1222), 40, 124);
+ Add_Action (Table.States (1222), 41, 125);
+ Add_Action (Table.States (1222), 52, 126);
+ Add_Action (Table.States (1222), 74, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (1222), 76, 127);
+ Add_Action (Table.States (1222), 79, 31);
+ Add_Action (Table.States (1222), 95, 128);
+ Add_Action (Table.States (1222), 96, 129);
+ Add_Action (Table.States (1222), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (1222), 104, 130);
+ Add_Action (Table.States (1222), 105, 120);
+ Add_Action (Table.States (1222), 106, 34);
+ Add_Action (Table.States (1222), 107, 35);
+ Table.States (1222).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (1222), 118, 131);
+ Add_Goto (Table.States (1222), 129, 42);
+ Add_Goto (Table.States (1222), 192, 132);
+ Add_Goto (Table.States (1222), 193, 1256);
+ Add_Goto (Table.States (1222), 198, 134);
+ Add_Goto (Table.States (1222), 240, 135);
+ Add_Goto (Table.States (1222), 259, 136);
+ Add_Goto (Table.States (1222), 273, 93);
+ Add_Goto (Table.States (1222), 276, 137);
+ Add_Goto (Table.States (1222), 283, 138);
+ Add_Goto (Table.States (1222), 284, 139);
+ Add_Goto (Table.States (1222), 285, 140);
+ Add_Goto (Table.States (1222), 286, 141);
+ Add_Goto (Table.States (1222), 287, 142);
+ Add_Goto (Table.States (1222), 288, 143);
+ Add_Goto (Table.States (1222), 294, 98);
+ Add_Goto (Table.States (1222), 302, 144);
+ Add_Goto (Table.States (1222), 321, 145);
+ Add_Goto (Table.States (1222), 322, 146);
+ Add_Goto (Table.States (1222), 331, 147);
+ Table.States (1222).Kernel := To_Vector ((0 => (147, 83, 1,
False)));
+ Table.States (1222).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (1223).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1223), 97, 1257);
+ Table.States (1223).Kernel := To_Vector ((0 => (147, 123, 1,
False)));
+ Table.States (1223).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1257)));
+ Table.States (1224).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (1224), 10, 1016);
+ Add_Action (Table.States (1224), 74, Reduce, (120, 0), 2, null,
null);
+ Add_Action (Table.States (1224), 97, Reduce, (120, 0), 2, null,
null);
+ Table.States (1224).Kernel := To_Vector (((120, 228, 0, False),
(228, 228, 2, True)));
+ Table.States (1224).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 120, 2)));
+ Table.States (1225).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1225), 49, 1258);
+ Table.States (1225).Kernel := To_Vector ((0 => (260, 74, 2,
False)));
+ Table.States (1225).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 49, 1258)));
+ Table.States (1226).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1226), 41, 713);
+ Add_Action (Table.States (1226), 54, 716);
+ Table.States (1226).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (1226), 281, 1259);
+ Table.States (1226).Kernel := To_Vector ((0 => (163, 74, 2,
False)));
+ Table.States (1226).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 41, 713)));
+ Table.States (1227).Action_List.Set_Capacity (25);
+ Add_Action (Table.States (1227), 4, 1);
+ Add_Action (Table.States (1227), 5, 2);
+ Add_Action (Table.States (1227), 13, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (1227), 15, 3);
+ Add_Action (Table.States (1227), 17, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (1227), 18, 4);
+ Add_Action (Table.States (1227), 24, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (1227), 27, 5);
+ Add_Action (Table.States (1227), 28, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (1227), 31, 9);
+ Add_Action (Table.States (1227), 32, 10);
+ Add_Action (Table.States (1227), 37, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (1227), 41, 13);
+ Add_Action (Table.States (1227), 48, 16);
+ Add_Action (Table.States (1227), 52, 20);
+ Add_Action (Table.States (1227), 57, 21);
+ Add_Action (Table.States (1227), 58, 22);
+ Add_Action (Table.States (1227), 61, 24);
+ Add_Action (Table.States (1227), 72, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (1227), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (1227), 79, 31);
+ Add_Action (Table.States (1227), 94, 32);
+ Add_Action (Table.States (1227), 105, 361);
+ Add_Action (Table.States (1227), 106, 34);
+ Add_Action (Table.States (1227), 107, 35);
+ Table.States (1227).Goto_List.Set_Capacity (31);
+ Add_Goto (Table.States (1227), 114, 37);
+ Add_Goto (Table.States (1227), 124, 39);
+ Add_Goto (Table.States (1227), 127, 40);
+ Add_Goto (Table.States (1227), 129, 42);
+ Add_Goto (Table.States (1227), 132, 43);
+ Add_Goto (Table.States (1227), 133, 44);
+ Add_Goto (Table.States (1227), 134, 45);
+ Add_Goto (Table.States (1227), 140, 48);
+ Add_Goto (Table.States (1227), 152, 51);
+ Add_Goto (Table.States (1227), 153, 52);
+ Add_Goto (Table.States (1227), 162, 54);
+ Add_Goto (Table.States (1227), 191, 58);
+ Add_Goto (Table.States (1227), 197, 60);
+ Add_Goto (Table.States (1227), 218, 69);
+ Add_Goto (Table.States (1227), 223, 71);
+ Add_Goto (Table.States (1227), 233, 73);
+ Add_Goto (Table.States (1227), 240, 74);
+ Add_Goto (Table.States (1227), 258, 84);
+ Add_Goto (Table.States (1227), 262, 87);
+ Add_Goto (Table.States (1227), 273, 93);
+ Add_Goto (Table.States (1227), 277, 94);
+ Add_Goto (Table.States (1227), 291, 97);
+ Add_Goto (Table.States (1227), 294, 98);
+ Add_Goto (Table.States (1227), 295, 99);
+ Add_Goto (Table.States (1227), 299, 100);
+ Add_Goto (Table.States (1227), 300, 362);
+ Add_Goto (Table.States (1227), 301, 1260);
+ Add_Goto (Table.States (1227), 303, 101);
+ Add_Goto (Table.States (1227), 304, 102);
+ Add_Goto (Table.States (1227), 307, 364);
+ Add_Goto (Table.States (1227), 324, 115);
+ Table.States (1227).Kernel := To_Vector ((0 => (188, 88, 0,
False)));
+ Table.States (1227).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 301, 0)));
+ Table.States (1228).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1228), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (245, 1), 9,
object_declaration_1'Access, null);
- Table.States (1217).Kernel := To_Vector ((0 => (244, 96, 0,
False)));
- Table.States (1217).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 244, 9)));
- Table.States (1218).Action_List.Set_Capacity (40);
- Add_Action (Table.States (1218), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (244, 2), 9,
+ Table.States (1228).Kernel := To_Vector ((0 => (245, 97, 0,
False)));
+ Table.States (1228).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 245, 9)));
+ Table.States (1229).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1229), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (245, 2), 9,
object_declaration_2'Access, null);
- Table.States (1218).Kernel := To_Vector ((0 => (244, 96, 0,
False)));
- Table.States (1218).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 244, 9)));
- Table.States (1219).Action_List.Set_Capacity (40);
- Add_Action (Table.States (1219), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (244, 0), 9,
+ Table.States (1229).Kernel := To_Vector ((0 => (245, 97, 0,
False)));
+ Table.States (1229).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 245, 9)));
+ Table.States (1230).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1230), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (245, 0), 9,
object_declaration_0'Access, null);
- Table.States (1219).Kernel := To_Vector ((0 => (244, 96, 0,
False)));
- Table.States (1219).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 244, 9)));
- Table.States (1220).Action_List.Set_Capacity (40);
- Add_Action (Table.States (1220), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (179, 0), 9,
+ Table.States (1230).Kernel := To_Vector ((0 => (245, 97, 0,
False)));
+ Table.States (1230).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 245, 9)));
+ Table.States (1231).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1231), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (180, 0), 9,
entry_declaration_0'Access, null);
- Table.States (1220).Kernel := To_Vector ((0 => (179, 96, 0,
False)));
- Table.States (1220).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 179, 9)));
- Table.States (1221).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1221), 96, 1250);
- Table.States (1221).Kernel := To_Vector ((0 => (307, 240, 1,
False)));
- Table.States (1221).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1250)));
- Table.States (1222).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1222), (22, 23, 77), (172, 0), 4,
elsif_expression_item_0'Access, null);
- Table.States (1222).Kernel := To_Vector ((0 => (172, 192, 0,
False)));
- Table.States (1222).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 172, 4)));
- Table.States (1223).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1223), 85, 1251);
- Table.States (1223).Kernel := To_Vector ((0 => (144, 301, 3,
False)));
- Table.States (1223).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 85, 1251)));
- Table.States (1224).Action_List.Set_Capacity (14);
- Add_Action (Table.States (1224), 3, 121);
- Add_Action (Table.States (1224), 39, 122);
- Add_Action (Table.States (1224), 40, 123);
- Add_Action (Table.States (1224), 41, 124);
- Add_Action (Table.States (1224), 52, 125);
- Add_Action (Table.States (1224), 76, 126);
- Add_Action (Table.States (1224), 77, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (1224), 94, 127);
- Add_Action (Table.States (1224), 95, 128);
- Add_Action (Table.States (1224), 96, Reduce, (192, 1), 0, null,
null);
- Add_Action (Table.States (1224), 103, 129);
- Add_Action (Table.States (1224), 104, 119);
- Add_Action (Table.States (1224), 105, 33);
- Add_Action (Table.States (1224), 106, 34);
- Table.States (1224).Goto_List.Set_Capacity (20);
- Add_Goto (Table.States (1224), 117, 130);
- Add_Goto (Table.States (1224), 128, 41);
- Add_Goto (Table.States (1224), 191, 131);
- Add_Goto (Table.States (1224), 192, 1252);
- Add_Goto (Table.States (1224), 197, 133);
- Add_Goto (Table.States (1224), 239, 134);
- Add_Goto (Table.States (1224), 258, 135);
- Add_Goto (Table.States (1224), 272, 92);
- Add_Goto (Table.States (1224), 275, 136);
- Add_Goto (Table.States (1224), 282, 137);
- Add_Goto (Table.States (1224), 283, 138);
- Add_Goto (Table.States (1224), 284, 139);
- Add_Goto (Table.States (1224), 285, 140);
- Add_Goto (Table.States (1224), 286, 141);
- Add_Goto (Table.States (1224), 287, 142);
- Add_Goto (Table.States (1224), 293, 97);
- Add_Goto (Table.States (1224), 301, 143);
- Add_Goto (Table.States (1224), 320, 144);
- Add_Goto (Table.States (1224), 321, 145);
- Add_Goto (Table.States (1224), 330, 146);
- Table.States (1224).Kernel := To_Vector ((0 => (254, 82, 0,
False)));
- Table.States (1224).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 192, 0)));
- Table.States (1225).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1225), 49, 1253);
- Table.States (1225).Kernel := To_Vector ((0 => (203, 74, 1,
False)));
- Table.States (1225).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 49, 1253)));
- Table.States (1226).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1226), (74, 96), (205, 0), 3, null,
null);
- Table.States (1226).Kernel := To_Vector ((0 => (205, 77, 0,
False)));
- Table.States (1226).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 205, 3)));
- Table.States (1227).Action_List.Set_Capacity (8);
- Add_Action (Table.States (1227), (29, 47, 48, 50, 69, 71, 74,
104), (204, 0), 9,
- formal_package_declaration_0'Access, null);
- Table.States (1227).Kernel := To_Vector ((0 => (204, 96, 0,
False)));
- Table.States (1227).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 204, 9)));
- Table.States (1228).Action_List.Set_Capacity (8);
- Add_Action (Table.States (1228), (29, 47, 48, 50, 69, 71, 74,
104), (198, 0), 9,
- formal_object_declaration_0'Access, null);
- Table.States (1228).Kernel := To_Vector ((0 => (198, 96, 0,
False)));
- Table.States (1228).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 198, 9)));
- Table.States (1229).Action_List.Set_Capacity (46);
- Add_Action (Table.States (1229), (4, 5, 13, 15, 17, 18, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
- 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
- 107), (222, 0), 10, if_statement_0'Access, null);
- Table.States (1229).Kernel := To_Vector ((0 => (222, 96, 0,
False)));
- Table.States (1229).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 222, 10)));
- Table.States (1230).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1230), 96, 1254);
- Table.States (1230).Kernel := To_Vector ((0 => (247, 240, 1,
False)));
- Table.States (1230).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1254)));
- Table.States (1231).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1231), 33, 1255);
- Table.States (1231).Kernel := To_Vector ((0 => (177, 104, 3,
False)));
- Table.States (1231).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 1255)));
+ Table.States (1231).Kernel := To_Vector ((0 => (180, 97, 0,
False)));
+ Table.States (1231).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 180, 9)));
Table.States (1232).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1232), 35, 1256);
- Table.States (1232).Kernel := To_Vector ((0 => (176, 192, 4,
False)));
- Table.States (1232).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 1256)));
- Table.States (1233).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1233), 96, 1257);
- Table.States (1233).Kernel := To_Vector ((0 => (271, 266, 1,
False)));
- Table.States (1233).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1257)));
+ Add_Action (Table.States (1232), 97, 1261);
+ Table.States (1232).Kernel := To_Vector ((0 => (308, 241, 1,
False)));
+ Table.States (1232).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1261)));
+ Table.States (1233).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (1233), (22, 23, 77), (173, 0), 4,
elsif_expression_item_0'Access, null);
+ Table.States (1233).Kernel := To_Vector ((0 => (173, 193, 0,
False)));
+ Table.States (1233).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 173, 4)));
Table.States (1234).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1234), 96, 1258);
- Table.States (1234).Kernel := To_Vector ((0 => (316, 220, 1,
False)));
- Table.States (1234).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1258)));
- Table.States (1235).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1235), 24, 1259);
- Table.States (1235).Kernel := To_Vector ((0 => (319, 318, 2,
False)));
- Table.States (1235).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1259)));
- Table.States (1236).Action_List.Set_Capacity (40);
- Add_Action (Table.States (1236), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (319, 1), 10,
- task_type_declaration_1'Access,
task_type_declaration_1_check'Access);
- Table.States (1236).Kernel := To_Vector ((0 => (319, 96, 0,
False)));
- Table.States (1236).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 319, 10)));
- Table.States (1237).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1237), 96, 1260);
- Table.States (1237).Kernel := To_Vector ((0 => (305, 220, 1,
False)));
- Table.States (1237).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1260)));
- Table.States (1238).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1238), (74, 82, 96), (120, 1), 6,
array_type_definition_1'Access, null);
- Table.States (1238).Kernel := To_Vector ((0 => (120, 147, 0,
False)));
- Table.States (1238).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 120, 6)));
- Table.States (1239).Action_List.Set_Capacity (3);
- Add_Action (Table.States (1239), (74, 82, 96), (120, 0), 6,
array_type_definition_0'Access, null);
- Table.States (1239).Kernel := To_Vector ((0 => (120, 147, 0,
False)));
- Table.States (1239).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 120, 6)));
- Table.States (1240).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1240), 80, 1203);
- Table.States (1240).Kernel := To_Vector ((0 => (225, 53, 1,
False)));
- Table.States (1240).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 80, 1203)));
- Table.States (1241).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1241), (74, 96), (279, 0), 4, null,
null);
- Table.States (1241).Kernel := To_Vector ((0 => (279, 301, 0,
False)));
- Table.States (1241).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 279, 4)));
- Table.States (1242).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1242), 79, 445);
- Add_Action (Table.States (1242), 87, 1261);
- Table.States (1242).Kernel := To_Vector (((166, 166, 2, True),
(329, 166, 1, False)));
- Table.States (1242).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 87, 1261)));
+ Add_Action (Table.States (1234), 86, 1262);
+ Table.States (1234).Kernel := To_Vector ((0 => (145, 302, 3,
False)));
+ Table.States (1234).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 86, 1262)));
+ Table.States (1235).Action_List.Set_Capacity (15);
+ Add_Action (Table.States (1235), 3, 122);
+ Add_Action (Table.States (1235), 39, 123);
+ Add_Action (Table.States (1235), 40, 124);
+ Add_Action (Table.States (1235), 41, 125);
+ Add_Action (Table.States (1235), 52, 126);
+ Add_Action (Table.States (1235), 76, 127);
+ Add_Action (Table.States (1235), 77, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (1235), 79, 31);
+ Add_Action (Table.States (1235), 95, 128);
+ Add_Action (Table.States (1235), 96, 129);
+ Add_Action (Table.States (1235), 97, Reduce, (193, 1), 0, null,
null);
+ Add_Action (Table.States (1235), 104, 130);
+ Add_Action (Table.States (1235), 105, 120);
+ Add_Action (Table.States (1235), 106, 34);
+ Add_Action (Table.States (1235), 107, 35);
+ Table.States (1235).Goto_List.Set_Capacity (20);
+ Add_Goto (Table.States (1235), 118, 131);
+ Add_Goto (Table.States (1235), 129, 42);
+ Add_Goto (Table.States (1235), 192, 132);
+ Add_Goto (Table.States (1235), 193, 1263);
+ Add_Goto (Table.States (1235), 198, 134);
+ Add_Goto (Table.States (1235), 240, 135);
+ Add_Goto (Table.States (1235), 259, 136);
+ Add_Goto (Table.States (1235), 273, 93);
+ Add_Goto (Table.States (1235), 276, 137);
+ Add_Goto (Table.States (1235), 283, 138);
+ Add_Goto (Table.States (1235), 284, 139);
+ Add_Goto (Table.States (1235), 285, 140);
+ Add_Goto (Table.States (1235), 286, 141);
+ Add_Goto (Table.States (1235), 287, 142);
+ Add_Goto (Table.States (1235), 288, 143);
+ Add_Goto (Table.States (1235), 294, 98);
+ Add_Goto (Table.States (1235), 302, 144);
+ Add_Goto (Table.States (1235), 321, 145);
+ Add_Goto (Table.States (1235), 322, 146);
+ Add_Goto (Table.States (1235), 331, 147);
+ Table.States (1235).Kernel := To_Vector ((0 => (255, 83, 0,
False)));
+ Table.States (1235).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 193, 0)));
+ Table.States (1236).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1236), 49, 1264);
+ Table.States (1236).Kernel := To_Vector ((0 => (204, 74, 1,
False)));
+ Table.States (1236).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 49, 1264)));
+ Table.States (1237).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1237), (74, 97), (206, 0), 3, null,
null);
+ Table.States (1237).Kernel := To_Vector ((0 => (206, 77, 0,
False)));
+ Table.States (1237).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 206, 3)));
+ Table.States (1238).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (1238), (29, 47, 48, 50, 69, 71, 74,
105), (205, 0), 9,
+ formal_package_declaration_0'Access, null);
+ Table.States (1238).Kernel := To_Vector ((0 => (205, 97, 0,
False)));
+ Table.States (1238).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 205, 9)));
+ Table.States (1239).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (1239), (29, 47, 48, 50, 69, 71, 74,
105), (199, 0), 9,
+ formal_object_declaration_0'Access, null);
+ Table.States (1239).Kernel := To_Vector ((0 => (199, 97, 0,
False)));
+ Table.States (1239).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 199, 9)));
+ Table.States (1240).Action_List.Set_Capacity (47);
+ Add_Action (Table.States (1240), (4, 5, 13, 15, 17, 18, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+ 40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66,
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+ 107, 108), (223, 0), 10, if_statement_0'Access, null);
+ Table.States (1240).Kernel := To_Vector ((0 => (223, 97, 0,
False)));
+ Table.States (1240).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 223, 10)));
+ Table.States (1241).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1241), 97, 1265);
+ Table.States (1241).Kernel := To_Vector ((0 => (248, 241, 1,
False)));
+ Table.States (1241).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1265)));
+ Table.States (1242).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1242), 33, 1266);
+ Table.States (1242).Kernel := To_Vector ((0 => (178, 105, 3,
False)));
+ Table.States (1242).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 1266)));
Table.States (1243).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1243), 15, 1262);
- Table.States (1243).Kernel := To_Vector ((0 => (327, 24, 2,
False)));
- Table.States (1243).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 15, 1262)));
- Table.States (1244).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1244), (24, 72), (328, 0), 2,
variant_list_0'Access, null);
- Table.States (1244).Kernel := To_Vector ((0 => (328, 329, 0,
True)));
- Table.States (1244).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 328, 2)));
- Table.States (1244).Minimal_Complete_Actions_Recursive := True;
- Table.States (1245).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1245), 74, 337);
- Add_Action (Table.States (1245), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (1245).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (1245), 122, 1263);
- Table.States (1245).Kernel := To_Vector ((0 => (146, 192, 1,
False)));
- Table.States (1245).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (1246).Action_List.Set_Capacity (5);
- Add_Action (Table.States (1246), (15, 24, 28, 72, 104), (146, 1),
5, component_declaration_1'Access, null);
- Table.States (1246).Kernel := To_Vector ((0 => (146, 96, 0,
False)));
- Table.States (1246).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 146, 5)));
- Table.States (1247).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1247), 74, 337);
- Add_Action (Table.States (1247), 96, Reduce, (122, 1), 0, null,
null);
- Table.States (1247).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (1247), 122, 1264);
- Table.States (1247).Kernel := To_Vector ((0 => (259, 49, 1,
False)));
- Table.States (1247).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 122, 0)));
- Table.States (1248).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1248), (74, 96), (162, 0), 6,
derived_type_definition_0'Access, null);
- Table.States (1248).Kernel := To_Vector ((0 => (162, 280, 0,
False)));
- Table.States (1248).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 162, 6)));
- Table.States (1249).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1249), (24, 72), (187, 0), 6,
exception_handler_0'Access, null);
- Table.States (1249).Kernel := To_Vector ((0 => (187, 300, 0,
False)));
- Table.States (1249).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 187, 6)));
- Table.States (1250).Action_List.Set_Capacity (40);
- Add_Action (Table.States (1250), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (307, 0), 10,
- subprogram_body_0'Access, subprogram_body_0_check'Access);
- Table.States (1250).Kernel := To_Vector ((0 => (307, 96, 0,
False)));
- Table.States (1250).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 307, 10)));
- Table.States (1251).Action_List.Set_Capacity (11);
- Add_Action (Table.States (1251), 3, 121);
- Add_Action (Table.States (1251), 39, 122);
- Add_Action (Table.States (1251), 40, 123);
- Add_Action (Table.States (1251), 41, 124);
- Add_Action (Table.States (1251), 76, 126);
- Add_Action (Table.States (1251), 94, 127);
- Add_Action (Table.States (1251), 95, 128);
- Add_Action (Table.States (1251), 103, 129);
- Add_Action (Table.States (1251), 104, 119);
- Add_Action (Table.States (1251), 105, 33);
- Add_Action (Table.States (1251), 106, 34);
- Table.States (1251).Goto_List.Set_Capacity (11);
- Add_Goto (Table.States (1251), 117, 130);
- Add_Goto (Table.States (1251), 128, 41);
- Add_Goto (Table.States (1251), 197, 133);
- Add_Goto (Table.States (1251), 239, 134);
- Add_Goto (Table.States (1251), 258, 135);
- Add_Goto (Table.States (1251), 272, 92);
- Add_Goto (Table.States (1251), 293, 97);
- Add_Goto (Table.States (1251), 301, 1265);
- Add_Goto (Table.States (1251), 320, 144);
- Add_Goto (Table.States (1251), 321, 145);
- Add_Goto (Table.States (1251), 330, 146);
- Table.States (1251).Kernel := To_Vector ((0 => (144, 85, 2,
False)));
- Table.States (1251).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 103, 129)));
+ Add_Action (Table.States (1243), 35, 1267);
+ Table.States (1243).Kernel := To_Vector ((0 => (177, 193, 4,
False)));
+ Table.States (1243).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 35, 1267)));
+ Table.States (1244).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1244), 97, 1268);
+ Table.States (1244).Kernel := To_Vector ((0 => (272, 267, 1,
False)));
+ Table.States (1244).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1268)));
+ Table.States (1245).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1245), 97, 1269);
+ Table.States (1245).Kernel := To_Vector ((0 => (317, 221, 1,
False)));
+ Table.States (1245).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1269)));
+ Table.States (1246).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1246), 24, 1270);
+ Table.States (1246).Kernel := To_Vector ((0 => (320, 319, 2,
False)));
+ Table.States (1246).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1270)));
+ Table.States (1247).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1247), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (320, 1), 10,
+ task_type_declaration_1'Access,
task_type_declaration_1_check'Access);
+ Table.States (1247).Kernel := To_Vector ((0 => (320, 97, 0,
False)));
+ Table.States (1247).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 320, 10)));
+ Table.States (1248).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1248), 97, 1271);
+ Table.States (1248).Kernel := To_Vector ((0 => (306, 221, 1,
False)));
+ Table.States (1248).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1271)));
+ Table.States (1249).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (1249), (74, 83, 97), (121, 1), 6,
array_type_definition_1'Access, null);
+ Table.States (1249).Kernel := To_Vector ((0 => (121, 148, 0,
False)));
+ Table.States (1249).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 121, 6)));
+ Table.States (1250).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (1250), (74, 83, 97), (121, 0), 6,
array_type_definition_0'Access, null);
+ Table.States (1250).Kernel := To_Vector ((0 => (121, 148, 0,
False)));
+ Table.States (1250).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 121, 6)));
+ Table.States (1251).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1251), 81, 1214);
+ Table.States (1251).Kernel := To_Vector ((0 => (226, 53, 1,
False)));
+ Table.States (1251).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 81, 1214)));
Table.States (1252).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1252), (77, 96), (254, 0), 8,
parameter_specification_0'Access, null);
- Table.States (1252).Kernel := To_Vector ((0 => (254, 192, 0,
False)));
- Table.States (1252).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 254, 8)));
+ Add_Action (Table.States (1252), (74, 97), (280, 0), 4, null,
null);
+ Table.States (1252).Kernel := To_Vector ((0 => (280, 302, 0,
False)));
+ Table.States (1252).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 280, 4)));
Table.States (1253).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1253), (74, 96), (203, 0), 6,
formal_derived_type_definition_0'Access, null);
- Table.States (1253).Kernel := To_Vector ((0 => (203, 49, 0,
False)));
- Table.States (1253).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 203, 6)));
- Table.States (1254).Action_List.Set_Capacity (40);
- Add_Action (Table.States (1254), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (247, 0), 11,
+ Add_Action (Table.States (1253), 80, 447);
+ Add_Action (Table.States (1253), 88, 1272);
+ Table.States (1253).Kernel := To_Vector (((167, 167, 2, True),
(330, 167, 1, False)));
+ Table.States (1253).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 88, 1272)));
+ Table.States (1254).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1254), 15, 1273);
+ Table.States (1254).Kernel := To_Vector ((0 => (328, 24, 2,
False)));
+ Table.States (1254).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 15, 1273)));
+ Table.States (1255).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1255), (24, 72), (329, 0), 2,
variant_list_0'Access, null);
+ Table.States (1255).Kernel := To_Vector ((0 => (329, 330, 0,
True)));
+ Table.States (1255).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 329, 2)));
+ Table.States (1255).Minimal_Complete_Actions_Recursive := True;
+ Table.States (1256).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1256), 74, 338);
+ Add_Action (Table.States (1256), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (1256).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (1256), 123, 1274);
+ Table.States (1256).Kernel := To_Vector ((0 => (147, 193, 1,
False)));
+ Table.States (1256).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (1257).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (1257), (15, 24, 28, 72, 105), (147, 1),
5, component_declaration_1'Access, null);
+ Table.States (1257).Kernel := To_Vector ((0 => (147, 97, 0,
False)));
+ Table.States (1257).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 147, 5)));
+ Table.States (1258).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1258), 74, 338);
+ Add_Action (Table.States (1258), 97, Reduce, (123, 1), 0, null,
null);
+ Table.States (1258).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (1258), 123, 1275);
+ Table.States (1258).Kernel := To_Vector ((0 => (260, 49, 1,
False)));
+ Table.States (1258).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 123, 0)));
+ Table.States (1259).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1259), (74, 97), (163, 0), 6,
derived_type_definition_0'Access, null);
+ Table.States (1259).Kernel := To_Vector ((0 => (163, 281, 0,
False)));
+ Table.States (1259).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 163, 6)));
+ Table.States (1260).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1260), (24, 72), (188, 0), 6,
exception_handler_0'Access, null);
+ Table.States (1260).Kernel := To_Vector ((0 => (188, 301, 0,
False)));
+ Table.States (1260).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 188, 6)));
+ Table.States (1261).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1261), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (308, 0), 10,
+ subprogram_body_0'Access, subprogram_body_0_check'Access);
+ Table.States (1261).Kernel := To_Vector ((0 => (308, 97, 0,
False)));
+ Table.States (1261).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 308, 10)));
+ Table.States (1262).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (1262), 3, 122);
+ Add_Action (Table.States (1262), 39, 123);
+ Add_Action (Table.States (1262), 40, 124);
+ Add_Action (Table.States (1262), 41, 125);
+ Add_Action (Table.States (1262), 76, 127);
+ Add_Action (Table.States (1262), 79, 31);
+ Add_Action (Table.States (1262), 95, 128);
+ Add_Action (Table.States (1262), 96, 129);
+ Add_Action (Table.States (1262), 104, 130);
+ Add_Action (Table.States (1262), 105, 120);
+ Add_Action (Table.States (1262), 106, 34);
+ Add_Action (Table.States (1262), 107, 35);
+ Table.States (1262).Goto_List.Set_Capacity (11);
+ Add_Goto (Table.States (1262), 118, 131);
+ Add_Goto (Table.States (1262), 129, 42);
+ Add_Goto (Table.States (1262), 198, 134);
+ Add_Goto (Table.States (1262), 240, 135);
+ Add_Goto (Table.States (1262), 259, 136);
+ Add_Goto (Table.States (1262), 273, 93);
+ Add_Goto (Table.States (1262), 294, 98);
+ Add_Goto (Table.States (1262), 302, 1276);
+ Add_Goto (Table.States (1262), 321, 145);
+ Add_Goto (Table.States (1262), 322, 146);
+ Add_Goto (Table.States (1262), 331, 147);
+ Table.States (1262).Kernel := To_Vector ((0 => (145, 86, 2,
False)));
+ Table.States (1262).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 130)));
+ Table.States (1263).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1263), (77, 97), (255, 0), 8,
parameter_specification_0'Access, null);
+ Table.States (1263).Kernel := To_Vector ((0 => (255, 193, 0,
False)));
+ Table.States (1263).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 255, 8)));
+ Table.States (1264).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1264), (74, 97), (204, 0), 6,
formal_derived_type_definition_0'Access, null);
+ Table.States (1264).Kernel := To_Vector ((0 => (204, 49, 0,
False)));
+ Table.States (1264).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 204, 6)));
+ Table.States (1265).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1265), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (248, 0), 11,
package_body_0'Access, package_body_0_check'Access);
- Table.States (1254).Kernel := To_Vector ((0 => (247, 96, 0,
False)));
- Table.States (1254).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 247, 11)));
- Table.States (1255).Action_List.Set_Capacity (11);
- Add_Action (Table.States (1255), 3, 121);
- Add_Action (Table.States (1255), 39, 122);
- Add_Action (Table.States (1255), 40, 474);
- Add_Action (Table.States (1255), 41, 124);
- Add_Action (Table.States (1255), 76, 126);
- Add_Action (Table.States (1255), 94, 127);
- Add_Action (Table.States (1255), 95, 128);
- Add_Action (Table.States (1255), 103, 129);
- Add_Action (Table.States (1255), 104, 119);
- Add_Action (Table.States (1255), 105, 33);
- Add_Action (Table.States (1255), 106, 34);
- Table.States (1255).Goto_List.Set_Capacity (14);
- Add_Goto (Table.States (1255), 117, 130);
- Add_Goto (Table.States (1255), 128, 41);
- Add_Goto (Table.States (1255), 167, 1266);
- Add_Goto (Table.States (1255), 197, 133);
- Add_Goto (Table.States (1255), 239, 477);
- Add_Goto (Table.States (1255), 258, 135);
- Add_Goto (Table.States (1255), 272, 92);
- Add_Goto (Table.States (1255), 277, 478);
- Add_Goto (Table.States (1255), 293, 97);
- Add_Goto (Table.States (1255), 301, 479);
- Add_Goto (Table.States (1255), 314, 480);
- Add_Goto (Table.States (1255), 320, 144);
- Add_Goto (Table.States (1255), 321, 145);
- Add_Goto (Table.States (1255), 330, 146);
- Table.States (1255).Kernel := To_Vector ((0 => (177, 33, 2,
False)));
- Table.States (1255).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 104, 119)));
- Table.States (1256).Action_List.Set_Capacity (16);
- Add_Action (Table.States (1256), 13, Reduce, (159, 1), 0, null,
null);
- Add_Action (Table.States (1256), 25, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (1256), 28, 183);
- Add_Action (Table.States (1256), 29, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (1256), 30, 8);
- Add_Action (Table.States (1256), 40, 12);
- Add_Action (Table.States (1256), 46, 14);
- Add_Action (Table.States (1256), 47, 15);
- Add_Action (Table.States (1256), 48, 16);
- Add_Action (Table.States (1256), 50, Reduce, (246, 2), 0, null,
null);
- Add_Action (Table.States (1256), 51, 19);
- Add_Action (Table.States (1256), 63, 25);
- Add_Action (Table.States (1256), 66, 26);
- Add_Action (Table.States (1256), 69, 27);
- Add_Action (Table.States (1256), 71, 28);
- Add_Action (Table.States (1256), 104, 185);
- Table.States (1256).Goto_List.Set_Capacity (53);
- Add_Goto (Table.States (1256), 112, 35);
- Add_Goto (Table.States (1256), 121, 37);
- Add_Goto (Table.States (1256), 127, 40);
- Add_Goto (Table.States (1256), 134, 45);
- Add_Goto (Table.States (1256), 135, 46);
- Add_Goto (Table.States (1256), 157, 391);
- Add_Goto (Table.States (1256), 158, 392);
- Add_Goto (Table.States (1256), 159, 1267);
- Add_Goto (Table.States (1256), 179, 54);
- Add_Goto (Table.States (1256), 182, 55);
- Add_Goto (Table.States (1256), 186, 56);
- Add_Goto (Table.States (1256), 193, 58);
- Add_Goto (Table.States (1256), 206, 60);
- Add_Goto (Table.States (1256), 207, 61);
- Add_Goto (Table.States (1256), 209, 62);
- Add_Goto (Table.States (1256), 210, 63);
- Add_Goto (Table.States (1256), 213, 64);
- Add_Goto (Table.States (1256), 214, 65);
- Add_Goto (Table.States (1256), 215, 66);
- Add_Goto (Table.States (1256), 216, 67);
- Add_Goto (Table.States (1256), 219, 69);
- Add_Goto (Table.States (1256), 223, 71);
- Add_Goto (Table.States (1256), 243, 74);
- Add_Goto (Table.States (1256), 244, 75);
- Add_Goto (Table.States (1256), 245, 76);
- Add_Goto (Table.States (1256), 246, 77);
- Add_Goto (Table.States (1256), 247, 78);
- Add_Goto (Table.States (1256), 248, 79);
- Add_Goto (Table.States (1256), 249, 80);
- Add_Goto (Table.States (1256), 250, 81);
- Add_Goto (Table.States (1256), 251, 82);
- Add_Goto (Table.States (1256), 257, 394);
- Add_Goto (Table.States (1256), 259, 84);
- Add_Goto (Table.States (1256), 260, 85);
- Add_Goto (Table.States (1256), 262, 87);
- Add_Goto (Table.States (1256), 263, 88);
- Add_Goto (Table.States (1256), 264, 89);
- Add_Goto (Table.States (1256), 265, 90);
- Add_Goto (Table.States (1256), 271, 91);
- Add_Goto (Table.States (1256), 281, 94);
- Add_Goto (Table.States (1256), 289, 95);
- Add_Goto (Table.States (1256), 304, 102);
- Add_Goto (Table.States (1256), 305, 103);
- Add_Goto (Table.States (1256), 307, 105);
- Add_Goto (Table.States (1256), 308, 106);
- Add_Goto (Table.States (1256), 309, 107);
- Add_Goto (Table.States (1256), 311, 108);
- Add_Goto (Table.States (1256), 313, 109);
- Add_Goto (Table.States (1256), 316, 111);
- Add_Goto (Table.States (1256), 317, 112);
- Add_Goto (Table.States (1256), 319, 113);
- Add_Goto (Table.States (1256), 325, 115);
- Add_Goto (Table.States (1256), 331, 116);
- Table.States (1256).Kernel := To_Vector ((0 => (176, 35, 3,
False)));
- Table.States (1256).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 159, 0)));
- Table.States (1257).Action_List.Set_Capacity (40);
- Add_Action (Table.States (1257), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (271, 0), 11,
+ Table.States (1265).Kernel := To_Vector ((0 => (248, 97, 0,
False)));
+ Table.States (1265).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 248, 11)));
+ Table.States (1266).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (1266), 3, 122);
+ Add_Action (Table.States (1266), 39, 123);
+ Add_Action (Table.States (1266), 40, 477);
+ Add_Action (Table.States (1266), 41, 125);
+ Add_Action (Table.States (1266), 76, 127);
+ Add_Action (Table.States (1266), 79, 31);
+ Add_Action (Table.States (1266), 95, 128);
+ Add_Action (Table.States (1266), 96, 129);
+ Add_Action (Table.States (1266), 104, 130);
+ Add_Action (Table.States (1266), 105, 120);
+ Add_Action (Table.States (1266), 106, 34);
+ Add_Action (Table.States (1266), 107, 35);
+ Table.States (1266).Goto_List.Set_Capacity (14);
+ Add_Goto (Table.States (1266), 118, 131);
+ Add_Goto (Table.States (1266), 129, 42);
+ Add_Goto (Table.States (1266), 168, 1277);
+ Add_Goto (Table.States (1266), 198, 134);
+ Add_Goto (Table.States (1266), 240, 480);
+ Add_Goto (Table.States (1266), 259, 136);
+ Add_Goto (Table.States (1266), 273, 93);
+ Add_Goto (Table.States (1266), 278, 481);
+ Add_Goto (Table.States (1266), 294, 98);
+ Add_Goto (Table.States (1266), 302, 482);
+ Add_Goto (Table.States (1266), 315, 483);
+ Add_Goto (Table.States (1266), 321, 145);
+ Add_Goto (Table.States (1266), 322, 146);
+ Add_Goto (Table.States (1266), 331, 147);
+ Table.States (1266).Kernel := To_Vector ((0 => (178, 33, 2,
False)));
+ Table.States (1266).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 105, 120)));
+ Table.States (1267).Action_List.Set_Capacity (16);
+ Add_Action (Table.States (1267), 13, Reduce, (160, 1), 0, null,
null);
+ Add_Action (Table.States (1267), 25, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (1267), 28, 184);
+ Add_Action (Table.States (1267), 29, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (1267), 30, 8);
+ Add_Action (Table.States (1267), 40, 12);
+ Add_Action (Table.States (1267), 46, 14);
+ Add_Action (Table.States (1267), 47, 15);
+ Add_Action (Table.States (1267), 48, 16);
+ Add_Action (Table.States (1267), 50, Reduce, (247, 2), 0, null,
null);
+ Add_Action (Table.States (1267), 51, 19);
+ Add_Action (Table.States (1267), 63, 25);
+ Add_Action (Table.States (1267), 66, 26);
+ Add_Action (Table.States (1267), 69, 27);
+ Add_Action (Table.States (1267), 71, 28);
+ Add_Action (Table.States (1267), 105, 186);
+ Table.States (1267).Goto_List.Set_Capacity (53);
+ Add_Goto (Table.States (1267), 113, 36);
+ Add_Goto (Table.States (1267), 122, 38);
+ Add_Goto (Table.States (1267), 128, 41);
+ Add_Goto (Table.States (1267), 135, 46);
+ Add_Goto (Table.States (1267), 136, 47);
+ Add_Goto (Table.States (1267), 158, 392);
+ Add_Goto (Table.States (1267), 159, 393);
+ Add_Goto (Table.States (1267), 160, 1278);
+ Add_Goto (Table.States (1267), 180, 55);
+ Add_Goto (Table.States (1267), 183, 56);
+ Add_Goto (Table.States (1267), 187, 57);
+ Add_Goto (Table.States (1267), 194, 59);
+ Add_Goto (Table.States (1267), 207, 61);
+ Add_Goto (Table.States (1267), 208, 62);
+ Add_Goto (Table.States (1267), 210, 63);
+ Add_Goto (Table.States (1267), 211, 64);
+ Add_Goto (Table.States (1267), 214, 65);
+ Add_Goto (Table.States (1267), 215, 66);
+ Add_Goto (Table.States (1267), 216, 67);
+ Add_Goto (Table.States (1267), 217, 68);
+ Add_Goto (Table.States (1267), 220, 70);
+ Add_Goto (Table.States (1267), 224, 72);
+ Add_Goto (Table.States (1267), 244, 75);
+ Add_Goto (Table.States (1267), 245, 76);
+ Add_Goto (Table.States (1267), 246, 77);
+ Add_Goto (Table.States (1267), 247, 78);
+ Add_Goto (Table.States (1267), 248, 79);
+ Add_Goto (Table.States (1267), 249, 80);
+ Add_Goto (Table.States (1267), 250, 81);
+ Add_Goto (Table.States (1267), 251, 82);
+ Add_Goto (Table.States (1267), 252, 83);
+ Add_Goto (Table.States (1267), 258, 395);
+ Add_Goto (Table.States (1267), 260, 85);
+ Add_Goto (Table.States (1267), 261, 86);
+ Add_Goto (Table.States (1267), 263, 88);
+ Add_Goto (Table.States (1267), 264, 89);
+ Add_Goto (Table.States (1267), 265, 90);
+ Add_Goto (Table.States (1267), 266, 91);
+ Add_Goto (Table.States (1267), 272, 92);
+ Add_Goto (Table.States (1267), 282, 95);
+ Add_Goto (Table.States (1267), 290, 96);
+ Add_Goto (Table.States (1267), 305, 103);
+ Add_Goto (Table.States (1267), 306, 104);
+ Add_Goto (Table.States (1267), 308, 106);
+ Add_Goto (Table.States (1267), 309, 107);
+ Add_Goto (Table.States (1267), 310, 108);
+ Add_Goto (Table.States (1267), 312, 109);
+ Add_Goto (Table.States (1267), 314, 110);
+ Add_Goto (Table.States (1267), 317, 112);
+ Add_Goto (Table.States (1267), 318, 113);
+ Add_Goto (Table.States (1267), 320, 114);
+ Add_Goto (Table.States (1267), 326, 116);
+ Add_Goto (Table.States (1267), 332, 117);
+ Table.States (1267).Kernel := To_Vector ((0 => (177, 35, 3,
False)));
+ Table.States (1267).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 160, 0)));
+ Table.States (1268).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1268), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (272, 0), 11,
protected_type_declaration_0'Access,
protected_type_declaration_0_check'Access);
- Table.States (1257).Kernel := To_Vector ((0 => (271, 96, 0,
False)));
- Table.States (1257).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 271, 11)));
- Table.States (1258).Action_List.Set_Capacity (40);
- Add_Action (Table.States (1258), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (316, 0), 11,
+ Table.States (1268).Kernel := To_Vector ((0 => (272, 97, 0,
False)));
+ Table.States (1268).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 272, 11)));
+ Table.States (1269).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1269), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (317, 0), 11,
task_body_0'Access, task_body_0_check'Access);
- Table.States (1258).Kernel := To_Vector ((0 => (316, 96, 0,
False)));
- Table.States (1258).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 316, 11)));
- Table.States (1259).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1259), 96, Reduce, (220, 1), 0, null,
null);
- Add_Action (Table.States (1259), 104, 149);
- Table.States (1259).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (1259), 220, 1268);
- Table.States (1259).Kernel := To_Vector ((0 => (319, 24, 1,
False)));
- Table.States (1259).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 220, 0)));
- Table.States (1260).Action_List.Set_Capacity (40);
- Add_Action (Table.States (1260), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (305, 0), 11,
+ Table.States (1269).Kernel := To_Vector ((0 => (317, 97, 0,
False)));
+ Table.States (1269).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 317, 11)));
+ Table.States (1270).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1270), 97, Reduce, (221, 1), 0, null,
null);
+ Add_Action (Table.States (1270), 105, 150);
+ Table.States (1270).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (1270), 221, 1279);
+ Table.States (1270).Kernel := To_Vector ((0 => (320, 24, 1,
False)));
+ Table.States (1270).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 221, 0)));
+ Table.States (1271).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1271), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (306, 0), 11,
single_task_declaration_0'Access,
single_task_declaration_0_check'Access);
- Table.States (1260).Kernel := To_Vector ((0 => (305, 96, 0,
False)));
- Table.States (1260).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 305, 11)));
- Table.States (1261).Action_List.Set_Capacity (6);
- Add_Action (Table.States (1261), 15, 886);
- Add_Action (Table.States (1261), 24, Reduce, (150, 1), 0, null,
null);
- Add_Action (Table.States (1261), 28, 183);
- Add_Action (Table.States (1261), 41, 887);
- Add_Action (Table.States (1261), 72, Reduce, (150, 1), 0, null,
null);
- Add_Action (Table.States (1261), 104, 164);
- Table.States (1261).Goto_List.Set_Capacity (10);
- Add_Goto (Table.States (1261), 121, 888);
- Add_Goto (Table.States (1261), 127, 40);
- Add_Goto (Table.States (1261), 146, 889);
- Add_Goto (Table.States (1261), 148, 890);
- Add_Goto (Table.States (1261), 149, 891);
- Add_Goto (Table.States (1261), 150, 1269);
- Add_Goto (Table.States (1261), 182, 55);
- Add_Goto (Table.States (1261), 219, 893);
- Add_Goto (Table.States (1261), 281, 94);
- Add_Goto (Table.States (1261), 327, 894);
- Table.States (1261).Kernel := To_Vector ((0 => (329, 87, 0,
False)));
- Table.States (1261).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 150, 0)));
- Table.States (1262).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1262), 96, 1270);
- Table.States (1262).Kernel := To_Vector ((0 => (327, 15, 1,
False)));
- Table.States (1262).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1270)));
- Table.States (1263).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1263), 96, 1271);
- Table.States (1263).Kernel := To_Vector ((0 => (146, 122, 1,
False)));
- Table.States (1263).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1271)));
- Table.States (1264).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1264), 96, 1272);
- Table.States (1264).Kernel := To_Vector ((0 => (259, 122, 1,
False)));
- Table.States (1264).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1272)));
- Table.States (1265).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1265), 96, 1273);
- Table.States (1265).Kernel := To_Vector ((0 => (144, 301, 1,
False)));
- Table.States (1265).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1273)));
- Table.States (1266).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1266), 77, 1274);
- Table.States (1266).Kernel := To_Vector ((0 => (177, 167, 1,
False)));
- Table.States (1266).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 1274)));
- end Subr_20;
- procedure Subr_21
- is begin
- Table.States (1267).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1267), 13, 1275);
- Table.States (1267).Kernel := To_Vector ((0 => (176, 159, 3,
False)));
- Table.States (1267).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 13, 1275)));
- Table.States (1268).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1268), 96, 1276);
- Table.States (1268).Kernel := To_Vector ((0 => (319, 220, 1,
False)));
- Table.States (1268).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1276)));
- Table.States (1269).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1269), (24, 72), (329, 0), 4,
variant_0'Access, null);
- Table.States (1269).Kernel := To_Vector ((0 => (329, 150, 0,
False)));
- Table.States (1269).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 329, 4)));
- Table.States (1270).Action_List.Set_Capacity (5);
- Add_Action (Table.States (1270), (15, 24, 28, 72, 104), (327, 0),
7, variant_part_0'Access, null);
- Table.States (1270).Kernel := To_Vector ((0 => (327, 96, 0,
False)));
- Table.States (1270).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 327, 7)));
- Table.States (1271).Action_List.Set_Capacity (5);
- Add_Action (Table.States (1271), (15, 24, 28, 72, 104), (146, 0),
7, component_declaration_0'Access, null);
- Table.States (1271).Kernel := To_Vector ((0 => (146, 96, 0,
False)));
- Table.States (1271).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 146, 7)));
- Table.States (1272).Action_List.Set_Capacity (40);
- Add_Action (Table.States (1272), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (259, 0), 12,
- private_extension_declaration_0'Access, null);
- Table.States (1272).Kernel := To_Vector ((0 => (259, 96, 0,
False)));
- Table.States (1272).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 259, 12)));
- Table.States (1273).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1273), (24, 104), (144, 0), 8,
component_clause_0'Access, null);
- Table.States (1273).Kernel := To_Vector ((0 => (144, 96, 0,
False)));
- Table.States (1273).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 144, 8)));
- Table.States (1274).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1274), 72, Reduce, (253, 1), 0, null,
null);
- Add_Action (Table.States (1274), 76, 431);
- Table.States (1274).Goto_List.Set_Capacity (2);
- Add_Goto (Table.States (1274), 199, 344);
- Add_Goto (Table.States (1274), 253, 1277);
- Table.States (1274).Kernel := To_Vector ((0 => (177, 77, 0,
False)));
- Table.States (1274).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 253, 0)));
- Table.States (1275).Action_List.Set_Capacity (24);
- Add_Action (Table.States (1275), 4, 1);
- Add_Action (Table.States (1275), 5, 2);
- Add_Action (Table.States (1275), 13, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (1275), 15, 3);
- Add_Action (Table.States (1275), 17, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (1275), 18, 4);
- Add_Action (Table.States (1275), 24, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (1275), 26, Reduce, (300, 1), 0, null,
null);
- Add_Action (Table.States (1275), 27, 5);
- Add_Action (Table.States (1275), 28, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (1275), 31, 9);
- Add_Action (Table.States (1275), 32, 10);
- Add_Action (Table.States (1275), 37, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (1275), 41, 13);
- Add_Action (Table.States (1275), 48, 16);
- Add_Action (Table.States (1275), 52, 20);
- Add_Action (Table.States (1275), 57, 21);
- Add_Action (Table.States (1275), 58, 22);
- Add_Action (Table.States (1275), 61, 24);
- Add_Action (Table.States (1275), 73, Reduce, (132, 1), 0, null,
null);
- Add_Action (Table.States (1275), 93, 31);
- Add_Action (Table.States (1275), 104, 360);
- Add_Action (Table.States (1275), 105, 33);
- Add_Action (Table.States (1275), 106, 34);
- Table.States (1275).Goto_List.Set_Capacity (32);
- Add_Goto (Table.States (1275), 113, 36);
- Add_Goto (Table.States (1275), 123, 38);
- Add_Goto (Table.States (1275), 126, 39);
- Add_Goto (Table.States (1275), 128, 41);
- Add_Goto (Table.States (1275), 131, 42);
- Add_Goto (Table.States (1275), 132, 43);
- Add_Goto (Table.States (1275), 133, 44);
- Add_Goto (Table.States (1275), 139, 47);
- Add_Goto (Table.States (1275), 151, 50);
- Add_Goto (Table.States (1275), 152, 51);
- Add_Goto (Table.States (1275), 161, 53);
- Add_Goto (Table.States (1275), 190, 57);
- Add_Goto (Table.States (1275), 196, 59);
- Add_Goto (Table.States (1275), 217, 68);
- Add_Goto (Table.States (1275), 218, 1278);
- Add_Goto (Table.States (1275), 222, 70);
- Add_Goto (Table.States (1275), 232, 72);
- Add_Goto (Table.States (1275), 239, 73);
- Add_Goto (Table.States (1275), 257, 83);
- Add_Goto (Table.States (1275), 261, 86);
- Add_Goto (Table.States (1275), 272, 92);
- Add_Goto (Table.States (1275), 276, 93);
- Add_Goto (Table.States (1275), 290, 96);
- Add_Goto (Table.States (1275), 293, 97);
- Add_Goto (Table.States (1275), 294, 98);
- Add_Goto (Table.States (1275), 298, 99);
- Add_Goto (Table.States (1275), 299, 361);
- Add_Goto (Table.States (1275), 300, 390);
- Add_Goto (Table.States (1275), 302, 100);
- Add_Goto (Table.States (1275), 303, 101);
- Add_Goto (Table.States (1275), 306, 363);
- Add_Goto (Table.States (1275), 323, 114);
- Table.States (1275).Kernel := To_Vector ((0 => (176, 13, 2,
False)));
- Table.States (1275).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 218, 0)));
- Table.States (1276).Action_List.Set_Capacity (40);
- Add_Action (Table.States (1276), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
- 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
93, 104, 105, 106, 107), (319, 0), 13,
- task_type_declaration_0'Access,
task_type_declaration_0_check'Access);
- Table.States (1276).Kernel := To_Vector ((0 => (319, 96, 0,
False)));
- Table.States (1276).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 319, 13)));
+ Table.States (1271).Kernel := To_Vector ((0 => (306, 97, 0,
False)));
+ Table.States (1271).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 306, 11)));
+ Table.States (1272).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (1272), 15, 894);
+ Add_Action (Table.States (1272), 24, Reduce, (151, 1), 0, null,
null);
+ Add_Action (Table.States (1272), 28, 184);
+ Add_Action (Table.States (1272), 41, 895);
+ Add_Action (Table.States (1272), 72, Reduce, (151, 1), 0, null,
null);
+ Add_Action (Table.States (1272), 105, 165);
+ Table.States (1272).Goto_List.Set_Capacity (10);
+ Add_Goto (Table.States (1272), 122, 896);
+ Add_Goto (Table.States (1272), 128, 41);
+ Add_Goto (Table.States (1272), 147, 897);
+ Add_Goto (Table.States (1272), 149, 898);
+ Add_Goto (Table.States (1272), 150, 899);
+ Add_Goto (Table.States (1272), 151, 1280);
+ Add_Goto (Table.States (1272), 183, 56);
+ Add_Goto (Table.States (1272), 220, 901);
+ Add_Goto (Table.States (1272), 282, 95);
+ Add_Goto (Table.States (1272), 328, 902);
+ Table.States (1272).Kernel := To_Vector ((0 => (330, 88, 0,
False)));
+ Table.States (1272).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 151, 0)));
+ Table.States (1273).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1273), 97, 1281);
+ Table.States (1273).Kernel := To_Vector ((0 => (328, 15, 1,
False)));
+ Table.States (1273).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1281)));
+ Table.States (1274).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1274), 97, 1282);
+ Table.States (1274).Kernel := To_Vector ((0 => (147, 123, 1,
False)));
+ Table.States (1274).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1282)));
+ Table.States (1275).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1275), 97, 1283);
+ Table.States (1275).Kernel := To_Vector ((0 => (260, 123, 1,
False)));
+ Table.States (1275).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1283)));
+ Table.States (1276).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1276), 97, 1284);
+ Table.States (1276).Kernel := To_Vector ((0 => (145, 302, 1,
False)));
+ Table.States (1276).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1284)));
Table.States (1277).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1277), (1 => 72), (177, 0), 7,
entry_body_formal_part_0'Access, null);
- Table.States (1277).Kernel := To_Vector ((0 => (177, 253, 0,
False)));
- Table.States (1277).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 177, 7)));
+ Add_Action (Table.States (1277), 77, 1285);
+ Table.States (1277).Kernel := To_Vector ((0 => (178, 168, 1,
False)));
+ Table.States (1277).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 77, 1285)));
Table.States (1278).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1278), 24, 1279);
- Table.States (1278).Kernel := To_Vector ((0 => (176, 218, 2,
False)));
- Table.States (1278).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1279)));
- Table.States (1279).Action_List.Set_Capacity (2);
- Add_Action (Table.States (1279), 96, Reduce, (220, 1), 0, null,
null);
- Add_Action (Table.States (1279), 104, 149);
- Table.States (1279).Goto_List.Set_Capacity (1);
- Add_Goto (Table.States (1279), 220, 1280);
- Table.States (1279).Kernel := To_Vector ((0 => (176, 24, 1,
False)));
- Table.States (1279).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 220, 0)));
- Table.States (1280).Action_List.Set_Capacity (1);
- Add_Action (Table.States (1280), 96, 1281);
- Table.States (1280).Kernel := To_Vector ((0 => (176, 220, 1,
False)));
- Table.States (1280).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 96, 1281)));
- Table.States (1281).Action_List.Set_Capacity (7);
- Add_Action (Table.States (1281), (24, 25, 28, 29, 40, 46, 50),
(176, 0), 12, entry_body_0'Access,
+ Add_Action (Table.States (1278), 13, 1286);
+ Table.States (1278).Kernel := To_Vector ((0 => (177, 160, 3,
False)));
+ Table.States (1278).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 13, 1286)));
+ Table.States (1279).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1279), 97, 1287);
+ Table.States (1279).Kernel := To_Vector ((0 => (320, 221, 1,
False)));
+ Table.States (1279).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1287)));
+ Table.States (1280).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1280), (24, 72), (330, 0), 4,
variant_0'Access, null);
+ Table.States (1280).Kernel := To_Vector ((0 => (330, 151, 0,
False)));
+ Table.States (1280).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 330, 4)));
+ Table.States (1281).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (1281), (15, 24, 28, 72, 105), (328, 0),
7, variant_part_0'Access, null);
+ Table.States (1281).Kernel := To_Vector ((0 => (328, 97, 0,
False)));
+ Table.States (1281).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 328, 7)));
+ Table.States (1282).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (1282), (15, 24, 28, 72, 105), (147, 0),
7, component_declaration_0'Access, null);
+ Table.States (1282).Kernel := To_Vector ((0 => (147, 97, 0,
False)));
+ Table.States (1282).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 147, 7)));
+ Table.States (1283).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1283), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (260, 0), 12,
+ private_extension_declaration_0'Access, null);
+ Table.States (1283).Kernel := To_Vector ((0 => (260, 97, 0,
False)));
+ Table.States (1283).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 260, 12)));
+ Table.States (1284).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1284), (24, 105), (145, 0), 8,
component_clause_0'Access, null);
+ Table.States (1284).Kernel := To_Vector ((0 => (145, 97, 0,
False)));
+ Table.States (1284).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 145, 8)));
+ Table.States (1285).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1285), 72, Reduce, (254, 1), 0, null,
null);
+ Add_Action (Table.States (1285), 76, 432);
+ Table.States (1285).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (1285), 200, 345);
+ Add_Goto (Table.States (1285), 254, 1288);
+ Table.States (1285).Kernel := To_Vector ((0 => (178, 77, 0,
False)));
+ Table.States (1285).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 254, 0)));
+ Table.States (1286).Action_List.Set_Capacity (25);
+ Add_Action (Table.States (1286), 4, 1);
+ Add_Action (Table.States (1286), 5, 2);
+ Add_Action (Table.States (1286), 13, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (1286), 15, 3);
+ Add_Action (Table.States (1286), 17, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (1286), 18, 4);
+ Add_Action (Table.States (1286), 24, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (1286), 26, Reduce, (301, 1), 0, null,
null);
+ Add_Action (Table.States (1286), 27, 5);
+ Add_Action (Table.States (1286), 28, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (1286), 31, 9);
+ Add_Action (Table.States (1286), 32, 10);
+ Add_Action (Table.States (1286), 37, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (1286), 41, 13);
+ Add_Action (Table.States (1286), 48, 16);
+ Add_Action (Table.States (1286), 52, 20);
+ Add_Action (Table.States (1286), 57, 21);
+ Add_Action (Table.States (1286), 58, 22);
+ Add_Action (Table.States (1286), 61, 24);
+ Add_Action (Table.States (1286), 73, Reduce, (133, 1), 0, null,
null);
+ Add_Action (Table.States (1286), 79, 31);
+ Add_Action (Table.States (1286), 94, 32);
+ Add_Action (Table.States (1286), 105, 361);
+ Add_Action (Table.States (1286), 106, 34);
+ Add_Action (Table.States (1286), 107, 35);
+ Table.States (1286).Goto_List.Set_Capacity (32);
+ Add_Goto (Table.States (1286), 114, 37);
+ Add_Goto (Table.States (1286), 124, 39);
+ Add_Goto (Table.States (1286), 127, 40);
+ Add_Goto (Table.States (1286), 129, 42);
+ Add_Goto (Table.States (1286), 132, 43);
+ Add_Goto (Table.States (1286), 133, 44);
+ Add_Goto (Table.States (1286), 134, 45);
+ Add_Goto (Table.States (1286), 140, 48);
+ Add_Goto (Table.States (1286), 152, 51);
+ Add_Goto (Table.States (1286), 153, 52);
+ Add_Goto (Table.States (1286), 162, 54);
+ Add_Goto (Table.States (1286), 191, 58);
+ Add_Goto (Table.States (1286), 197, 60);
+ Add_Goto (Table.States (1286), 218, 69);
+ Add_Goto (Table.States (1286), 219, 1289);
+ Add_Goto (Table.States (1286), 223, 71);
+ Add_Goto (Table.States (1286), 233, 73);
+ Add_Goto (Table.States (1286), 240, 74);
+ Add_Goto (Table.States (1286), 258, 84);
+ Add_Goto (Table.States (1286), 262, 87);
+ Add_Goto (Table.States (1286), 273, 93);
+ Add_Goto (Table.States (1286), 277, 94);
+ Add_Goto (Table.States (1286), 291, 97);
+ Add_Goto (Table.States (1286), 294, 98);
+ Add_Goto (Table.States (1286), 295, 99);
+ Add_Goto (Table.States (1286), 299, 100);
+ Add_Goto (Table.States (1286), 300, 362);
+ Add_Goto (Table.States (1286), 301, 391);
+ Add_Goto (Table.States (1286), 303, 101);
+ Add_Goto (Table.States (1286), 304, 102);
+ Add_Goto (Table.States (1286), 307, 364);
+ Add_Goto (Table.States (1286), 324, 115);
+ Table.States (1286).Kernel := To_Vector ((0 => (177, 13, 2,
False)));
+ Table.States (1286).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 219, 0)));
+ Table.States (1287).Action_List.Set_Capacity (41);
+ Add_Action (Table.States (1287), (4, 5, 13, 15, 17, 18, 24, 25,
27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+ 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74,
79, 94, 105, 106, 107, 108), (320, 0), 13,
+ task_type_declaration_0'Access,
task_type_declaration_0_check'Access);
+ Table.States (1287).Kernel := To_Vector ((0 => (320, 97, 0,
False)));
+ Table.States (1287).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 320, 13)));
+ Table.States (1288).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1288), (1 => 72), (178, 0), 7,
entry_body_formal_part_0'Access, null);
+ Table.States (1288).Kernel := To_Vector ((0 => (178, 254, 0,
False)));
+ Table.States (1288).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 178, 7)));
+ Table.States (1289).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1289), 24, 1290);
+ Table.States (1289).Kernel := To_Vector ((0 => (177, 219, 2,
False)));
+ Table.States (1289).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 24, 1290)));
+ Table.States (1290).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (1290), 97, Reduce, (221, 1), 0, null,
null);
+ Add_Action (Table.States (1290), 105, 150);
+ Table.States (1290).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (1290), 221, 1291);
+ Table.States (1290).Kernel := To_Vector ((0 => (177, 24, 1,
False)));
+ Table.States (1290).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 221, 0)));
+ Table.States (1291).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (1291), 97, 1292);
+ Table.States (1291).Kernel := To_Vector ((0 => (177, 221, 1,
False)));
+ Table.States (1291).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 97, 1292)));
+ Table.States (1292).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (1292), (24, 25, 28, 29, 40, 46, 50),
(177, 0), 12, entry_body_0'Access,
entry_body_0_check'Access);
- Table.States (1281).Kernel := To_Vector ((0 => (176, 96, 0,
False)));
- Table.States (1281).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 176, 12)));
+ Table.States (1292).Kernel := To_Vector ((0 => (177, 97, 0,
False)));
+ Table.States (1292).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 177, 12)));
end Subr_21;
begin
Subr_1;
diff --git a/packages/ada-mode/ada_process_lr1_main.adb
b/packages/ada-mode/ada_process_lr1_main.adb
index e198fe8..f9829fb 100644
--- a/packages/ada-mode/ada_process_lr1_main.adb
+++ b/packages/ada-mode/ada_process_lr1_main.adb
@@ -40,17 +40,17 @@ package body Ada_Process_LR1_Main is
use WisiToken.Parse.LR;
McKenzie_Param : constant McKenzie_Param_Type :=
(First_Terminal => 3,
- Last_Terminal => 107,
- First_Nonterminal => 108,
- Last_Nonterminal => 332,
+ Last_Terminal => 108,
+ First_Nonterminal => 109,
+ Last_Nonterminal => 333,
Insert =>
(4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 4, 4, 4, 4, 4, 4, 4, 4, 3,
4, 4, 4, 4, 4, 4, 4, 2, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4),
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4),
Delete =>
(4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4),
+ 4, 4, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4),
Push_Back =>
(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
@@ -61,7 +61,7 @@ package body Ada_Process_LR1_Main is
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2),
+ 2, 2, 2, 2, 2, 2, 2),
Undo_Reduce =>
(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
@@ -82,381 +82,384 @@ package body Ada_Process_LR1_Main is
function Actions return
WisiToken.Parse.LR.Semantic_Action_Array_Arrays.Vector
is begin
return Acts : WisiToken.Parse.LR.Semantic_Action_Array_Arrays.Vector
do
- Acts.Set_First_Last (108, 332);
- Acts (112).Set_First_Last (0, 0);
- Acts (112)(0) := (abstract_subprogram_declaration_0'Access, null);
- Acts (113).Set_First_Last (0, 1);
- Acts (113)(0) := (accept_statement_0'Access,
accept_statement_0_check'Access);
- Acts (113)(1) := (accept_statement_1'Access, null);
- Acts (114).Set_First_Last (0, 2);
- Acts (114)(0) := (access_definition_0'Access, null);
- Acts (114)(1) := (access_definition_1'Access, null);
- Acts (114)(2) := (access_definition_2'Access, null);
- Acts (115).Set_First_Last (0, 1);
- Acts (115)(0) := (actual_parameter_part_0'Access, null);
- Acts (115)(1) := (actual_parameter_part_1'Access, null);
- Acts (117).Set_First_Last (0, 4);
- Acts (117)(0) := (aggregate_0'Access, null);
- Acts (117)(1) := (aggregate_1'Access, null);
- Acts (117)(3) := (aggregate_3'Access, null);
- Acts (117)(4) := (aggregate_4'Access, null);
- Acts (120).Set_First_Last (0, 1);
- Acts (120)(0) := (array_type_definition_0'Access, null);
- Acts (120)(1) := (array_type_definition_1'Access, null);
- Acts (121).Set_First_Last (0, 3);
- Acts (121)(0) := (aspect_clause_0'Access, null);
- Acts (122).Set_First_Last (0, 1);
- Acts (122)(0) := (aspect_specification_opt_0'Access, null);
- Acts (123).Set_First_Last (0, 0);
- Acts (123)(0) := (assignment_statement_0'Access, null);
- Acts (124).Set_First_Last (0, 5);
- Acts (124)(0) := (association_opt_0'Access, null);
- Acts (124)(2) := (association_opt_2'Access, null);
- Acts (124)(3) := (association_opt_3'Access, null);
- Acts (124)(4) := (association_opt_4'Access, null);
- Acts (126).Set_First_Last (0, 0);
- Acts (126)(0) := (asynchronous_select_0'Access, null);
+ Acts.Set_First_Last (109, 333);
+ Acts (113).Set_First_Last (0, 0);
+ Acts (113)(0) := (abstract_subprogram_declaration_0'Access, null);
+ Acts (114).Set_First_Last (0, 1);
+ Acts (114)(0) := (accept_statement_0'Access,
accept_statement_0_check'Access);
+ Acts (114)(1) := (accept_statement_1'Access, null);
+ Acts (115).Set_First_Last (0, 2);
+ Acts (115)(0) := (access_definition_0'Access, null);
+ Acts (115)(1) := (access_definition_1'Access, null);
+ Acts (115)(2) := (access_definition_2'Access, null);
+ Acts (116).Set_First_Last (0, 1);
+ Acts (116)(0) := (actual_parameter_part_0'Access, null);
+ Acts (116)(1) := (actual_parameter_part_1'Access, null);
+ Acts (118).Set_First_Last (0, 5);
+ Acts (118)(0) := (aggregate_0'Access, null);
+ Acts (118)(1) := (aggregate_1'Access, null);
+ Acts (118)(3) := (aggregate_3'Access, null);
+ Acts (118)(4) := (aggregate_4'Access, null);
+ Acts (118)(5) := (aggregate_5'Access, null);
+ Acts (121).Set_First_Last (0, 1);
+ Acts (121)(0) := (array_type_definition_0'Access, null);
+ Acts (121)(1) := (array_type_definition_1'Access, null);
+ Acts (122).Set_First_Last (0, 3);
+ Acts (122)(0) := (aspect_clause_0'Access, null);
+ Acts (123).Set_First_Last (0, 1);
+ Acts (123)(0) := (aspect_specification_opt_0'Access, null);
+ Acts (124).Set_First_Last (0, 0);
+ Acts (124)(0) := (assignment_statement_0'Access, null);
+ Acts (125).Set_First_Last (0, 6);
+ Acts (125)(0) := (association_opt_0'Access, null);
+ Acts (125)(2) := (association_opt_2'Access, null);
+ Acts (125)(3) := (association_opt_3'Access, null);
+ Acts (125)(4) := (association_opt_4'Access, null);
+ Acts (125)(5) := (association_opt_5'Access, null);
Acts (127).Set_First_Last (0, 0);
- Acts (127)(0) := (at_clause_0'Access, null);
- Acts (131).Set_First_Last (0, 0);
- Acts (131)(0) := (block_label_0'Access,
block_label_0_check'Access);
- Acts (132).Set_First_Last (0, 1);
- Acts (132)(0) := (null, block_label_opt_0_check'Access);
- Acts (132)(1) := (null, null);
+ Acts (127)(0) := (asynchronous_select_0'Access, null);
+ Acts (128).Set_First_Last (0, 0);
+ Acts (128)(0) := (at_clause_0'Access, null);
+ Acts (132).Set_First_Last (0, 0);
+ Acts (132)(0) := (block_label_0'Access,
block_label_0_check'Access);
Acts (133).Set_First_Last (0, 1);
- Acts (133)(0) := (block_statement_0'Access,
block_statement_0_check'Access);
- Acts (133)(1) := (block_statement_1'Access,
block_statement_1_check'Access);
- Acts (136).Set_First_Last (0, 0);
- Acts (136)(0) := (case_expression_0'Access, null);
+ Acts (133)(0) := (null, block_label_opt_0_check'Access);
+ Acts (133)(1) := (null, null);
+ Acts (134).Set_First_Last (0, 1);
+ Acts (134)(0) := (block_statement_0'Access,
block_statement_0_check'Access);
+ Acts (134)(1) := (block_statement_1'Access,
block_statement_1_check'Access);
Acts (137).Set_First_Last (0, 0);
- Acts (137)(0) := (case_expression_alternative_0'Access, null);
- Acts (138).Set_First_Last (0, 1);
- Acts (138)(0) := (case_expression_alternative_list_0'Access, null);
- Acts (139).Set_First_Last (0, 0);
- Acts (139)(0) := (case_statement_0'Access, null);
+ Acts (137)(0) := (case_expression_0'Access, null);
+ Acts (138).Set_First_Last (0, 0);
+ Acts (138)(0) := (case_expression_alternative_0'Access, null);
+ Acts (139).Set_First_Last (0, 1);
+ Acts (139)(0) := (case_expression_alternative_list_0'Access, null);
Acts (140).Set_First_Last (0, 0);
- Acts (140)(0) := (case_statement_alternative_0'Access, null);
- Acts (141).Set_First_Last (0, 1);
- Acts (141)(0) := (case_statement_alternative_list_0'Access, null);
- Acts (142).Set_First_Last (0, 4);
- Acts (142)(2) := (compilation_unit_2'Access, null);
- Acts (143).Set_First_Last (0, 1);
- Acts (143)(0) := (compilation_unit_list_0'Access, null);
- Acts (143)(1) := (compilation_unit_list_1'Access,
compilation_unit_list_1_check'Access);
- Acts (144).Set_First_Last (0, 0);
- Acts (144)(0) := (component_clause_0'Access, null);
- Acts (146).Set_First_Last (0, 1);
- Acts (146)(0) := (component_declaration_0'Access, null);
- Acts (146)(1) := (component_declaration_1'Access, null);
- Acts (149).Set_First_Last (0, 4);
- Acts (149)(4) := (component_list_4'Access, null);
- Acts (152).Set_First_Last (0, 0);
- Acts (152)(0) := (conditional_entry_call_0'Access, null);
- Acts (157).Set_First_Last (0, 16);
- Acts (157)(9) := (declaration_9'Access, null);
- Acts (161).Set_First_Last (0, 1);
- Acts (161)(0) := (delay_statement_0'Access, null);
- Acts (161)(1) := (delay_statement_1'Access, null);
+ Acts (140)(0) := (case_statement_0'Access, null);
+ Acts (141).Set_First_Last (0, 0);
+ Acts (141)(0) := (case_statement_alternative_0'Access, null);
+ Acts (142).Set_First_Last (0, 1);
+ Acts (142)(0) := (case_statement_alternative_list_0'Access, null);
+ Acts (143).Set_First_Last (0, 4);
+ Acts (143)(2) := (compilation_unit_2'Access, null);
+ Acts (144).Set_First_Last (0, 1);
+ Acts (144)(0) := (compilation_unit_list_0'Access, null);
+ Acts (144)(1) := (compilation_unit_list_1'Access,
compilation_unit_list_1_check'Access);
+ Acts (145).Set_First_Last (0, 0);
+ Acts (145)(0) := (component_clause_0'Access, null);
+ Acts (147).Set_First_Last (0, 1);
+ Acts (147)(0) := (component_declaration_0'Access, null);
+ Acts (147)(1) := (component_declaration_1'Access, null);
+ Acts (150).Set_First_Last (0, 4);
+ Acts (150)(4) := (component_list_4'Access, null);
+ Acts (153).Set_First_Last (0, 0);
+ Acts (153)(0) := (conditional_entry_call_0'Access, null);
+ Acts (158).Set_First_Last (0, 16);
+ Acts (158)(9) := (declaration_9'Access, null);
Acts (162).Set_First_Last (0, 1);
- Acts (162)(0) := (derived_type_definition_0'Access, null);
- Acts (162)(1) := (derived_type_definition_1'Access, null);
- Acts (169).Set_First_Last (0, 2);
- Acts (169)(1) := (discriminant_part_opt_1'Access, null);
- Acts (172).Set_First_Last (0, 0);
- Acts (172)(0) := (elsif_expression_item_0'Access, null);
- Acts (173).Set_First_Last (0, 1);
- Acts (173)(0) := (elsif_expression_list_0'Access, null);
- Acts (174).Set_First_Last (0, 0);
- Acts (174)(0) := (elsif_statement_item_0'Access, null);
- Acts (175).Set_First_Last (0, 1);
- Acts (175)(0) := (elsif_statement_list_0'Access, null);
- Acts (176).Set_First_Last (0, 0);
- Acts (176)(0) := (entry_body_0'Access, entry_body_0_check'Access);
- Acts (177).Set_First_Last (0, 1);
- Acts (177)(0) := (entry_body_formal_part_0'Access, null);
- Acts (179).Set_First_Last (0, 1);
- Acts (179)(0) := (entry_declaration_0'Access, null);
- Acts (179)(1) := (entry_declaration_1'Access, null);
- Acts (182).Set_First_Last (0, 0);
- Acts (182)(0) := (enumeration_representation_clause_0'Access,
null);
+ Acts (162)(0) := (delay_statement_0'Access, null);
+ Acts (162)(1) := (delay_statement_1'Access, null);
+ Acts (163).Set_First_Last (0, 1);
+ Acts (163)(0) := (derived_type_definition_0'Access, null);
+ Acts (163)(1) := (derived_type_definition_1'Access, null);
+ Acts (170).Set_First_Last (0, 2);
+ Acts (170)(1) := (discriminant_part_opt_1'Access, null);
+ Acts (173).Set_First_Last (0, 0);
+ Acts (173)(0) := (elsif_expression_item_0'Access, null);
+ Acts (174).Set_First_Last (0, 1);
+ Acts (174)(0) := (elsif_expression_list_0'Access, null);
+ Acts (175).Set_First_Last (0, 0);
+ Acts (175)(0) := (elsif_statement_item_0'Access, null);
+ Acts (176).Set_First_Last (0, 1);
+ Acts (176)(0) := (elsif_statement_list_0'Access, null);
+ Acts (177).Set_First_Last (0, 0);
+ Acts (177)(0) := (entry_body_0'Access, entry_body_0_check'Access);
+ Acts (178).Set_First_Last (0, 1);
+ Acts (178)(0) := (entry_body_formal_part_0'Access, null);
+ Acts (180).Set_First_Last (0, 1);
+ Acts (180)(0) := (entry_declaration_0'Access, null);
+ Acts (180)(1) := (entry_declaration_1'Access, null);
Acts (183).Set_First_Last (0, 0);
- Acts (183)(0) := (enumeration_type_definition_0'Access, null);
- Acts (186).Set_First_Last (0, 0);
- Acts (186)(0) := (exception_declaration_0'Access, null);
- Acts (187).Set_First_Last (0, 1);
- Acts (187)(0) := (exception_handler_0'Access, null);
- Acts (187)(1) := (exception_handler_1'Access, null);
- Acts (188).Set_First_Last (0, 2);
- Acts (188)(0) := (exception_handler_list_0'Access, null);
- Acts (190).Set_First_Last (0, 1);
- Acts (190)(0) := (exit_statement_0'Access, null);
- Acts (190)(1) := (exit_statement_1'Access, null);
- Acts (193).Set_First_Last (0, 0);
- Acts (193)(0) := (expression_function_declaration_0'Access, null);
- Acts (194).Set_First_Last (0, 1);
- Acts (194)(0) := (extended_return_object_declaration_0'Access,
null);
- Acts (194)(1) := (extended_return_object_declaration_1'Access,
null);
- Acts (196).Set_First_Last (0, 1);
- Acts (196)(0) := (extended_return_statement_0'Access, null);
- Acts (196)(1) := (extended_return_statement_1'Access, null);
- Acts (198).Set_First_Last (0, 3);
- Acts (198)(0) := (formal_object_declaration_0'Access, null);
- Acts (198)(1) := (formal_object_declaration_1'Access, null);
- Acts (198)(2) := (formal_object_declaration_2'Access, null);
- Acts (198)(3) := (formal_object_declaration_3'Access, null);
- Acts (199).Set_First_Last (0, 0);
- Acts (199)(0) := (formal_part_0'Access, null);
- Acts (200).Set_First_Last (0, 3);
- Acts (200)(0) := (formal_subprogram_declaration_0'Access, null);
- Acts (200)(1) := (formal_subprogram_declaration_1'Access, null);
- Acts (200)(2) := (formal_subprogram_declaration_2'Access, null);
- Acts (200)(3) := (formal_subprogram_declaration_3'Access, null);
- Acts (201).Set_First_Last (0, 2);
- Acts (201)(0) := (formal_type_declaration_0'Access, null);
- Acts (201)(1) := (formal_type_declaration_1'Access, null);
- Acts (201)(2) := (formal_type_declaration_2'Access, null);
- Acts (203).Set_First_Last (0, 1);
- Acts (203)(0) := (formal_derived_type_definition_0'Access, null);
- Acts (203)(1) := (formal_derived_type_definition_1'Access, null);
- Acts (204).Set_First_Last (0, 0);
- Acts (204)(0) := (formal_package_declaration_0'Access, null);
- Acts (206).Set_First_Last (0, 2);
- Acts (206)(0) := (full_type_declaration_0'Access, null);
- Acts (207).Set_First_Last (0, 0);
- Acts (207)(0) := (function_specification_0'Access,
function_specification_0_check'Access);
- Acts (210).Set_First_Last (0, 1);
- Acts (210)(0) := (generic_formal_part_0'Access, null);
- Acts (210)(1) := (generic_formal_part_1'Access, null);
- Acts (213).Set_First_Last (0, 2);
- Acts (213)(0) := (generic_instantiation_0'Access, null);
- Acts (213)(1) := (generic_instantiation_1'Access, null);
- Acts (213)(2) := (generic_instantiation_2'Access, null);
- Acts (214).Set_First_Last (0, 0);
- Acts (214)(0) := (generic_package_declaration_0'Access, null);
- Acts (215).Set_First_Last (0, 2);
- Acts (215)(0) := (generic_renaming_declaration_0'Access, null);
- Acts (215)(1) := (generic_renaming_declaration_1'Access, null);
- Acts (215)(2) := (generic_renaming_declaration_2'Access, null);
- Acts (216).Set_First_Last (0, 0);
- Acts (216)(0) := (generic_subprogram_declaration_0'Access, null);
+ Acts (183)(0) := (enumeration_representation_clause_0'Access,
null);
+ Acts (184).Set_First_Last (0, 0);
+ Acts (184)(0) := (enumeration_type_definition_0'Access, null);
+ Acts (187).Set_First_Last (0, 0);
+ Acts (187)(0) := (exception_declaration_0'Access, null);
+ Acts (188).Set_First_Last (0, 1);
+ Acts (188)(0) := (exception_handler_0'Access, null);
+ Acts (188)(1) := (exception_handler_1'Access, null);
+ Acts (189).Set_First_Last (0, 2);
+ Acts (189)(0) := (exception_handler_list_0'Access, null);
+ Acts (191).Set_First_Last (0, 1);
+ Acts (191)(0) := (exit_statement_0'Access, null);
+ Acts (191)(1) := (exit_statement_1'Access, null);
+ Acts (194).Set_First_Last (0, 0);
+ Acts (194)(0) := (expression_function_declaration_0'Access, null);
+ Acts (195).Set_First_Last (0, 1);
+ Acts (195)(0) := (extended_return_object_declaration_0'Access,
null);
+ Acts (195)(1) := (extended_return_object_declaration_1'Access,
null);
+ Acts (197).Set_First_Last (0, 1);
+ Acts (197)(0) := (extended_return_statement_0'Access, null);
+ Acts (197)(1) := (extended_return_statement_1'Access, null);
+ Acts (199).Set_First_Last (0, 3);
+ Acts (199)(0) := (formal_object_declaration_0'Access, null);
+ Acts (199)(1) := (formal_object_declaration_1'Access, null);
+ Acts (199)(2) := (formal_object_declaration_2'Access, null);
+ Acts (199)(3) := (formal_object_declaration_3'Access, null);
+ Acts (200).Set_First_Last (0, 0);
+ Acts (200)(0) := (formal_part_0'Access, null);
+ Acts (201).Set_First_Last (0, 3);
+ Acts (201)(0) := (formal_subprogram_declaration_0'Access, null);
+ Acts (201)(1) := (formal_subprogram_declaration_1'Access, null);
+ Acts (201)(2) := (formal_subprogram_declaration_2'Access, null);
+ Acts (201)(3) := (formal_subprogram_declaration_3'Access, null);
+ Acts (202).Set_First_Last (0, 2);
+ Acts (202)(0) := (formal_type_declaration_0'Access, null);
+ Acts (202)(1) := (formal_type_declaration_1'Access, null);
+ Acts (202)(2) := (formal_type_declaration_2'Access, null);
+ Acts (204).Set_First_Last (0, 1);
+ Acts (204)(0) := (formal_derived_type_definition_0'Access, null);
+ Acts (204)(1) := (formal_derived_type_definition_1'Access, null);
+ Acts (205).Set_First_Last (0, 0);
+ Acts (205)(0) := (formal_package_declaration_0'Access, null);
+ Acts (207).Set_First_Last (0, 2);
+ Acts (207)(0) := (full_type_declaration_0'Access, null);
+ Acts (208).Set_First_Last (0, 0);
+ Acts (208)(0) := (function_specification_0'Access,
function_specification_0_check'Access);
+ Acts (211).Set_First_Last (0, 1);
+ Acts (211)(0) := (generic_formal_part_0'Access, null);
+ Acts (211)(1) := (generic_formal_part_1'Access, null);
+ Acts (214).Set_First_Last (0, 2);
+ Acts (214)(0) := (generic_instantiation_0'Access, null);
+ Acts (214)(1) := (generic_instantiation_1'Access, null);
+ Acts (214)(2) := (generic_instantiation_2'Access, null);
+ Acts (215).Set_First_Last (0, 0);
+ Acts (215)(0) := (generic_package_declaration_0'Access, null);
+ Acts (216).Set_First_Last (0, 2);
+ Acts (216)(0) := (generic_renaming_declaration_0'Access, null);
+ Acts (216)(1) := (generic_renaming_declaration_1'Access, null);
+ Acts (216)(2) := (generic_renaming_declaration_2'Access, null);
Acts (217).Set_First_Last (0, 0);
- Acts (217)(0) := (goto_label_0'Access, null);
- Acts (218).Set_First_Last (0, 1);
- Acts (218)(0) := (handled_sequence_of_statements_0'Access, null);
+ Acts (217)(0) := (generic_subprogram_declaration_0'Access, null);
+ Acts (218).Set_First_Last (0, 0);
+ Acts (218)(0) := (goto_label_0'Access, null);
Acts (219).Set_First_Last (0, 1);
- Acts (219)(0) := (identifier_list_0'Access, null);
- Acts (219)(1) := (identifier_list_1'Access, null);
+ Acts (219)(0) := (handled_sequence_of_statements_0'Access, null);
Acts (220).Set_First_Last (0, 1);
- Acts (220)(0) := (null, identifier_opt_0_check'Access);
- Acts (220)(1) := (null, null);
- Acts (221).Set_First_Last (0, 3);
- Acts (221)(0) := (if_expression_0'Access, null);
- Acts (221)(1) := (if_expression_1'Access, null);
- Acts (221)(2) := (if_expression_2'Access, null);
- Acts (221)(3) := (if_expression_3'Access, null);
+ Acts (220)(0) := (identifier_list_0'Access, null);
+ Acts (220)(1) := (identifier_list_1'Access, null);
+ Acts (221).Set_First_Last (0, 1);
+ Acts (221)(0) := (null, identifier_opt_0_check'Access);
+ Acts (221)(1) := (null, null);
Acts (222).Set_First_Last (0, 3);
- Acts (222)(0) := (if_statement_0'Access, null);
- Acts (222)(1) := (if_statement_1'Access, null);
- Acts (222)(2) := (if_statement_2'Access, null);
- Acts (222)(3) := (if_statement_3'Access, null);
- Acts (223).Set_First_Last (0, 1);
- Acts (223)(0) := (incomplete_type_declaration_0'Access, null);
- Acts (223)(1) := (incomplete_type_declaration_1'Access, null);
- Acts (224).Set_First_Last (0, 0);
- Acts (224)(0) := (index_constraint_0'Access, null);
- Acts (227).Set_First_Last (0, 1);
- Acts (227)(0) := (interface_list_0'Access, null);
- Acts (227)(1) := (interface_list_1'Access, null);
- Acts (229).Set_First_Last (0, 1);
- Acts (229)(0) := (iteration_scheme_0'Access, null);
- Acts (229)(1) := (iteration_scheme_1'Access, null);
- Acts (230).Set_First_Last (0, 5);
- Acts (230)(2) := (iterator_specification_2'Access, null);
- Acts (230)(5) := (iterator_specification_5'Access, null);
- Acts (232).Set_First_Last (0, 1);
- Acts (232)(0) := (loop_statement_0'Access,
loop_statement_0_check'Access);
- Acts (232)(1) := (loop_statement_1'Access,
loop_statement_1_check'Access);
- Acts (239).Set_First_Last (0, 7);
- Acts (239)(0) := (name_0'Access, null);
- Acts (239)(1) := (name_1'Access, null);
- Acts (239)(2) := (null, name_2_check'Access);
- Acts (239)(3) := (null, null);
- Acts (239)(4) := (null, null);
- Acts (239)(5) := (name_5'Access, name_5_check'Access);
- Acts (239)(6) := (null, null);
- Acts (239)(7) := (null, name_7_check'Access);
- Acts (240).Set_First_Last (0, 1);
- Acts (240)(0) := (null, name_opt_0_check'Access);
- Acts (240)(1) := (null, null);
- Acts (242).Set_First_Last (0, 3);
- Acts (242)(0) := (null_exclusion_opt_name_type_0'Access, null);
- Acts (242)(1) := (null_exclusion_opt_name_type_1'Access, null);
- Acts (242)(2) := (null_exclusion_opt_name_type_2'Access, null);
- Acts (242)(3) := (null_exclusion_opt_name_type_3'Access, null);
- Acts (243).Set_First_Last (0, 0);
- Acts (243)(0) := (null_procedure_declaration_0'Access, null);
- Acts (244).Set_First_Last (0, 7);
- Acts (244)(0) := (object_declaration_0'Access, null);
- Acts (244)(1) := (object_declaration_1'Access, null);
- Acts (244)(2) := (object_declaration_2'Access, null);
- Acts (244)(3) := (object_declaration_3'Access, null);
- Acts (244)(4) := (object_declaration_4'Access, null);
- Acts (244)(5) := (object_declaration_5'Access, null);
- Acts (245).Set_First_Last (0, 2);
- Acts (245)(0) := (object_renaming_declaration_0'Access, null);
- Acts (245)(1) := (object_renaming_declaration_1'Access, null);
- Acts (245)(2) := (object_renaming_declaration_2'Access, null);
+ Acts (222)(0) := (if_expression_0'Access, null);
+ Acts (222)(1) := (if_expression_1'Access, null);
+ Acts (222)(2) := (if_expression_2'Access, null);
+ Acts (222)(3) := (if_expression_3'Access, null);
+ Acts (223).Set_First_Last (0, 3);
+ Acts (223)(0) := (if_statement_0'Access, null);
+ Acts (223)(1) := (if_statement_1'Access, null);
+ Acts (223)(2) := (if_statement_2'Access, null);
+ Acts (223)(3) := (if_statement_3'Access, null);
+ Acts (224).Set_First_Last (0, 1);
+ Acts (224)(0) := (incomplete_type_declaration_0'Access, null);
+ Acts (224)(1) := (incomplete_type_declaration_1'Access, null);
+ Acts (225).Set_First_Last (0, 0);
+ Acts (225)(0) := (index_constraint_0'Access, null);
+ Acts (228).Set_First_Last (0, 1);
+ Acts (228)(0) := (interface_list_0'Access, null);
+ Acts (228)(1) := (interface_list_1'Access, null);
+ Acts (230).Set_First_Last (0, 1);
+ Acts (230)(0) := (iteration_scheme_0'Access, null);
+ Acts (230)(1) := (iteration_scheme_1'Access, null);
+ Acts (231).Set_First_Last (0, 5);
+ Acts (231)(2) := (iterator_specification_2'Access, null);
+ Acts (231)(5) := (iterator_specification_5'Access, null);
+ Acts (233).Set_First_Last (0, 1);
+ Acts (233)(0) := (loop_statement_0'Access,
loop_statement_0_check'Access);
+ Acts (233)(1) := (loop_statement_1'Access,
loop_statement_1_check'Access);
+ Acts (240).Set_First_Last (0, 8);
+ Acts (240)(0) := (name_0'Access, null);
+ Acts (240)(1) := (name_1'Access, null);
+ Acts (240)(2) := (null, name_2_check'Access);
+ Acts (240)(3) := (null, null);
+ Acts (240)(4) := (null, null);
+ Acts (240)(5) := (name_5'Access, name_5_check'Access);
+ Acts (240)(6) := (null, null);
+ Acts (240)(7) := (null, name_7_check'Access);
+ Acts (240)(8) := (null, null);
+ Acts (241).Set_First_Last (0, 1);
+ Acts (241)(0) := (null, name_opt_0_check'Access);
+ Acts (241)(1) := (null, null);
+ Acts (243).Set_First_Last (0, 3);
+ Acts (243)(0) := (null_exclusion_opt_name_type_0'Access, null);
+ Acts (243)(1) := (null_exclusion_opt_name_type_1'Access, null);
+ Acts (243)(2) := (null_exclusion_opt_name_type_2'Access, null);
+ Acts (243)(3) := (null_exclusion_opt_name_type_3'Access, null);
+ Acts (244).Set_First_Last (0, 0);
+ Acts (244)(0) := (null_procedure_declaration_0'Access, null);
+ Acts (245).Set_First_Last (0, 7);
+ Acts (245)(0) := (object_declaration_0'Access, null);
+ Acts (245)(1) := (object_declaration_1'Access, null);
+ Acts (245)(2) := (object_declaration_2'Access, null);
+ Acts (245)(3) := (object_declaration_3'Access, null);
+ Acts (245)(4) := (object_declaration_4'Access, null);
+ Acts (245)(5) := (object_declaration_5'Access, null);
Acts (246).Set_First_Last (0, 2);
- Acts (246)(0) := (overriding_indicator_opt_0'Access, null);
- Acts (246)(1) := (overriding_indicator_opt_1'Access, null);
- Acts (247).Set_First_Last (0, 1);
- Acts (247)(0) := (package_body_0'Access,
package_body_0_check'Access);
- Acts (247)(1) := (package_body_1'Access,
package_body_1_check'Access);
- Acts (248).Set_First_Last (0, 0);
- Acts (248)(0) := (package_body_stub_0'Access, null);
+ Acts (246)(0) := (object_renaming_declaration_0'Access, null);
+ Acts (246)(1) := (object_renaming_declaration_1'Access, null);
+ Acts (246)(2) := (object_renaming_declaration_2'Access, null);
+ Acts (247).Set_First_Last (0, 2);
+ Acts (247)(0) := (overriding_indicator_opt_0'Access, null);
+ Acts (247)(1) := (overriding_indicator_opt_1'Access, null);
+ Acts (248).Set_First_Last (0, 1);
+ Acts (248)(0) := (package_body_0'Access,
package_body_0_check'Access);
+ Acts (248)(1) := (package_body_1'Access,
package_body_1_check'Access);
Acts (249).Set_First_Last (0, 0);
- Acts (249)(0) := (package_declaration_0'Access, null);
+ Acts (249)(0) := (package_body_stub_0'Access, null);
Acts (250).Set_First_Last (0, 0);
- Acts (250)(0) := (package_renaming_declaration_0'Access, null);
- Acts (251).Set_First_Last (0, 1);
- Acts (251)(0) := (package_specification_0'Access,
package_specification_0_check'Access);
- Acts (251)(1) := (package_specification_1'Access,
package_specification_1_check'Access);
+ Acts (250)(0) := (package_declaration_0'Access, null);
+ Acts (251).Set_First_Last (0, 0);
+ Acts (251)(0) := (package_renaming_declaration_0'Access, null);
Acts (252).Set_First_Last (0, 1);
- Acts (252)(0) := (parameter_and_result_profile_0'Access, null);
- Acts (254).Set_First_Last (0, 4);
- Acts (254)(0) := (parameter_specification_0'Access, null);
- Acts (254)(1) := (parameter_specification_1'Access, null);
- Acts (254)(2) := (parameter_specification_2'Access, null);
- Acts (254)(3) := (parameter_specification_3'Access, null);
- Acts (256).Set_First_Last (0, 1);
- Acts (256)(0) := (paren_expression_0'Access, null);
- Acts (257).Set_First_Last (0, 2);
- Acts (257)(0) := (pragma_g_0'Access, null);
- Acts (257)(1) := (pragma_g_1'Access, null);
- Acts (257)(2) := (pragma_g_2'Access, null);
- Acts (258).Set_First_Last (0, 4);
- Acts (258)(0) := (primary_0'Access, null);
- Acts (258)(2) := (primary_2'Access, null);
- Acts (258)(4) := (primary_4'Access, null);
- Acts (259).Set_First_Last (0, 0);
- Acts (259)(0) := (private_extension_declaration_0'Access, null);
+ Acts (252)(0) := (package_specification_0'Access,
package_specification_0_check'Access);
+ Acts (252)(1) := (package_specification_1'Access,
package_specification_1_check'Access);
+ Acts (253).Set_First_Last (0, 1);
+ Acts (253)(0) := (parameter_and_result_profile_0'Access, null);
+ Acts (255).Set_First_Last (0, 4);
+ Acts (255)(0) := (parameter_specification_0'Access, null);
+ Acts (255)(1) := (parameter_specification_1'Access, null);
+ Acts (255)(2) := (parameter_specification_2'Access, null);
+ Acts (255)(3) := (parameter_specification_3'Access, null);
+ Acts (257).Set_First_Last (0, 1);
+ Acts (257)(0) := (paren_expression_0'Access, null);
+ Acts (258).Set_First_Last (0, 2);
+ Acts (258)(0) := (pragma_g_0'Access, null);
+ Acts (258)(1) := (pragma_g_1'Access, null);
+ Acts (258)(2) := (pragma_g_2'Access, null);
+ Acts (259).Set_First_Last (0, 4);
+ Acts (259)(0) := (primary_0'Access, null);
+ Acts (259)(2) := (primary_2'Access, null);
+ Acts (259)(4) := (primary_4'Access, null);
Acts (260).Set_First_Last (0, 0);
- Acts (260)(0) := (private_type_declaration_0'Access, null);
+ Acts (260)(0) := (private_extension_declaration_0'Access, null);
Acts (261).Set_First_Last (0, 0);
- Acts (261)(0) := (procedure_call_statement_0'Access, null);
+ Acts (261)(0) := (private_type_declaration_0'Access, null);
Acts (262).Set_First_Last (0, 0);
- Acts (262)(0) := (procedure_specification_0'Access,
procedure_specification_0_check'Access);
- Acts (264).Set_First_Last (0, 0);
- Acts (264)(0) := (protected_body_0'Access,
protected_body_0_check'Access);
+ Acts (262)(0) := (procedure_call_statement_0'Access, null);
+ Acts (263).Set_First_Last (0, 0);
+ Acts (263)(0) := (procedure_specification_0'Access,
procedure_specification_0_check'Access);
Acts (265).Set_First_Last (0, 0);
- Acts (265)(0) := (protected_body_stub_0'Access, null);
- Acts (266).Set_First_Last (0, 1);
- Acts (266)(0) := (protected_definition_0'Access,
protected_definition_0_check'Access);
- Acts (266)(1) := (protected_definition_1'Access,
protected_definition_1_check'Access);
- Acts (271).Set_First_Last (0, 1);
- Acts (271)(0) := (protected_type_declaration_0'Access,
protected_type_declaration_0_check'Access);
- Acts (271)(1) := (protected_type_declaration_1'Access,
protected_type_declaration_1_check'Access);
- Acts (272).Set_First_Last (0, 0);
- Acts (272)(0) := (qualified_expression_0'Access, null);
+ Acts (265)(0) := (protected_body_0'Access,
protected_body_0_check'Access);
+ Acts (266).Set_First_Last (0, 0);
+ Acts (266)(0) := (protected_body_stub_0'Access, null);
+ Acts (267).Set_First_Last (0, 1);
+ Acts (267)(0) := (protected_definition_0'Access,
protected_definition_0_check'Access);
+ Acts (267)(1) := (protected_definition_1'Access,
protected_definition_1_check'Access);
+ Acts (272).Set_First_Last (0, 1);
+ Acts (272)(0) := (protected_type_declaration_0'Access,
protected_type_declaration_0_check'Access);
+ Acts (272)(1) := (protected_type_declaration_1'Access,
protected_type_declaration_1_check'Access);
Acts (273).Set_First_Last (0, 0);
- Acts (273)(0) := (quantified_expression_0'Access, null);
- Acts (275).Set_First_Last (0, 1);
- Acts (275)(0) := (raise_expression_0'Access, null);
- Acts (276).Set_First_Last (0, 2);
- Acts (276)(0) := (raise_statement_0'Access, null);
- Acts (276)(1) := (raise_statement_1'Access, null);
- Acts (276)(2) := (raise_statement_2'Access, null);
+ Acts (273)(0) := (qualified_expression_0'Access, null);
+ Acts (274).Set_First_Last (0, 0);
+ Acts (274)(0) := (quantified_expression_0'Access, null);
+ Acts (276).Set_First_Last (0, 1);
+ Acts (276)(0) := (raise_expression_0'Access, null);
Acts (277).Set_First_Last (0, 2);
- Acts (277)(0) := (range_g_0'Access, null);
- Acts (280).Set_First_Last (0, 1);
- Acts (280)(0) := (record_definition_0'Access, null);
- Acts (281).Set_First_Last (0, 0);
- Acts (281)(0) := (record_representation_clause_0'Access, null);
- Acts (290).Set_First_Last (0, 1);
- Acts (290)(0) := (requeue_statement_0'Access, null);
- Acts (290)(1) := (requeue_statement_1'Access, null);
+ Acts (277)(0) := (raise_statement_0'Access, null);
+ Acts (277)(1) := (raise_statement_1'Access, null);
+ Acts (277)(2) := (raise_statement_2'Access, null);
+ Acts (278).Set_First_Last (0, 2);
+ Acts (278)(0) := (range_g_0'Access, null);
+ Acts (281).Set_First_Last (0, 1);
+ Acts (281)(0) := (record_definition_0'Access, null);
+ Acts (282).Set_First_Last (0, 0);
+ Acts (282)(0) := (record_representation_clause_0'Access, null);
Acts (291).Set_First_Last (0, 1);
- Acts (291)(0) := (result_profile_0'Access, null);
- Acts (291)(1) := (result_profile_1'Access, null);
- Acts (293).Set_First_Last (0, 3);
- Acts (293)(0) := (selected_component_0'Access,
selected_component_0_check'Access);
- Acts (293)(1) := (selected_component_1'Access, null);
- Acts (293)(2) := (selected_component_2'Access,
selected_component_2_check'Access);
- Acts (293)(3) := (selected_component_3'Access, null);
- Acts (294).Set_First_Last (0, 1);
- Acts (294)(0) := (selective_accept_0'Access, null);
- Acts (294)(1) := (selective_accept_1'Access, null);
- Acts (295).Set_First_Last (0, 5);
- Acts (295)(0) := (select_alternative_0'Access, null);
- Acts (295)(1) := (select_alternative_1'Access, null);
- Acts (295)(2) := (select_alternative_2'Access, null);
- Acts (295)(4) := (select_alternative_4'Access, null);
- Acts (296).Set_First_Last (0, 1);
- Acts (296)(0) := (select_alternative_list_0'Access, null);
- Acts (296)(1) := (select_alternative_list_1'Access, null);
- Acts (302).Set_First_Last (0, 0);
- Acts (302)(0) := (simple_return_statement_0'Access, null);
- Acts (303).Set_First_Last (0, 10);
- Acts (303)(0) := (simple_statement_0'Access, null);
- Acts (303)(3) := (simple_statement_3'Access, null);
- Acts (303)(8) := (simple_statement_8'Access, null);
- Acts (304).Set_First_Last (0, 1);
- Acts (304)(0) := (single_protected_declaration_0'Access,
single_protected_declaration_0_check'Access);
- Acts (304)(1) := (single_protected_declaration_1'Access,
single_protected_declaration_1_check'Access);
- Acts (305).Set_First_Last (0, 2);
- Acts (305)(0) := (single_task_declaration_0'Access,
single_task_declaration_0_check'Access);
- Acts (305)(1) := (single_task_declaration_1'Access,
single_task_declaration_1_check'Access);
- Acts (305)(2) := (single_task_declaration_2'Access, null);
- Acts (307).Set_First_Last (0, 0);
- Acts (307)(0) := (subprogram_body_0'Access,
subprogram_body_0_check'Access);
+ Acts (291)(0) := (requeue_statement_0'Access, null);
+ Acts (291)(1) := (requeue_statement_1'Access, null);
+ Acts (292).Set_First_Last (0, 1);
+ Acts (292)(0) := (result_profile_0'Access, null);
+ Acts (292)(1) := (result_profile_1'Access, null);
+ Acts (294).Set_First_Last (0, 3);
+ Acts (294)(0) := (selected_component_0'Access,
selected_component_0_check'Access);
+ Acts (294)(1) := (selected_component_1'Access, null);
+ Acts (294)(2) := (selected_component_2'Access,
selected_component_2_check'Access);
+ Acts (294)(3) := (selected_component_3'Access, null);
+ Acts (295).Set_First_Last (0, 1);
+ Acts (295)(0) := (selective_accept_0'Access, null);
+ Acts (295)(1) := (selective_accept_1'Access, null);
+ Acts (296).Set_First_Last (0, 5);
+ Acts (296)(0) := (select_alternative_0'Access, null);
+ Acts (296)(1) := (select_alternative_1'Access, null);
+ Acts (296)(2) := (select_alternative_2'Access, null);
+ Acts (296)(4) := (select_alternative_4'Access, null);
+ Acts (297).Set_First_Last (0, 1);
+ Acts (297)(0) := (select_alternative_list_0'Access, null);
+ Acts (297)(1) := (select_alternative_list_1'Access, null);
+ Acts (303).Set_First_Last (0, 0);
+ Acts (303)(0) := (simple_return_statement_0'Access, null);
+ Acts (304).Set_First_Last (0, 10);
+ Acts (304)(0) := (simple_statement_0'Access, null);
+ Acts (304)(3) := (simple_statement_3'Access, null);
+ Acts (304)(8) := (simple_statement_8'Access, null);
+ Acts (305).Set_First_Last (0, 1);
+ Acts (305)(0) := (single_protected_declaration_0'Access,
single_protected_declaration_0_check'Access);
+ Acts (305)(1) := (single_protected_declaration_1'Access,
single_protected_declaration_1_check'Access);
+ Acts (306).Set_First_Last (0, 2);
+ Acts (306)(0) := (single_task_declaration_0'Access,
single_task_declaration_0_check'Access);
+ Acts (306)(1) := (single_task_declaration_1'Access,
single_task_declaration_1_check'Access);
+ Acts (306)(2) := (single_task_declaration_2'Access, null);
Acts (308).Set_First_Last (0, 0);
- Acts (308)(0) := (subprogram_body_stub_0'Access, null);
+ Acts (308)(0) := (subprogram_body_0'Access,
subprogram_body_0_check'Access);
Acts (309).Set_First_Last (0, 0);
- Acts (309)(0) := (subprogram_declaration_0'Access, null);
- Acts (310).Set_First_Last (0, 2);
- Acts (310)(0) := (subprogram_default_0'Access, null);
- Acts (311).Set_First_Last (0, 0);
- Acts (311)(0) := (subprogram_renaming_declaration_0'Access, null);
- Acts (312).Set_First_Last (0, 1);
- Acts (312)(0) := (null, subprogram_specification_0_check'Access);
- Acts (312)(1) := (null, subprogram_specification_1_check'Access);
- Acts (313).Set_First_Last (0, 0);
- Acts (313)(0) := (subtype_declaration_0'Access, null);
- Acts (314).Set_First_Last (0, 3);
- Acts (314)(0) := (subtype_indication_0'Access, null);
- Acts (314)(1) := (subtype_indication_1'Access, null);
- Acts (314)(2) := (subtype_indication_2'Access, null);
- Acts (314)(3) := (subtype_indication_3'Access, null);
- Acts (315).Set_First_Last (0, 0);
- Acts (315)(0) := (subunit_0'Access, null);
+ Acts (309)(0) := (subprogram_body_stub_0'Access, null);
+ Acts (310).Set_First_Last (0, 0);
+ Acts (310)(0) := (subprogram_declaration_0'Access, null);
+ Acts (311).Set_First_Last (0, 2);
+ Acts (311)(0) := (subprogram_default_0'Access, null);
+ Acts (312).Set_First_Last (0, 0);
+ Acts (312)(0) := (subprogram_renaming_declaration_0'Access, null);
+ Acts (313).Set_First_Last (0, 1);
+ Acts (313)(0) := (null, subprogram_specification_0_check'Access);
+ Acts (313)(1) := (null, subprogram_specification_1_check'Access);
+ Acts (314).Set_First_Last (0, 0);
+ Acts (314)(0) := (subtype_declaration_0'Access, null);
+ Acts (315).Set_First_Last (0, 3);
+ Acts (315)(0) := (subtype_indication_0'Access, null);
+ Acts (315)(1) := (subtype_indication_1'Access, null);
+ Acts (315)(2) := (subtype_indication_2'Access, null);
+ Acts (315)(3) := (subtype_indication_3'Access, null);
Acts (316).Set_First_Last (0, 0);
- Acts (316)(0) := (task_body_0'Access, task_body_0_check'Access);
+ Acts (316)(0) := (subunit_0'Access, null);
Acts (317).Set_First_Last (0, 0);
- Acts (317)(0) := (task_body_stub_0'Access, null);
- Acts (318).Set_First_Last (0, 1);
- Acts (318)(0) := (task_definition_0'Access, null);
- Acts (318)(1) := (task_definition_1'Access, null);
- Acts (319).Set_First_Last (0, 2);
- Acts (319)(0) := (task_type_declaration_0'Access,
task_type_declaration_0_check'Access);
- Acts (319)(1) := (task_type_declaration_1'Access,
task_type_declaration_1_check'Access);
- Acts (319)(2) := (task_type_declaration_2'Access, null);
- Acts (323).Set_First_Last (0, 0);
- Acts (323)(0) := (timed_entry_call_0'Access, null);
- Acts (327).Set_First_Last (0, 0);
- Acts (327)(0) := (variant_part_0'Access, null);
- Acts (328).Set_First_Last (0, 1);
- Acts (328)(0) := (variant_list_0'Access, null);
- Acts (329).Set_First_Last (0, 0);
- Acts (329)(0) := (variant_0'Access, null);
- Acts (331).Set_First_Last (0, 2);
- Acts (331)(0) := (use_clause_0'Access, null);
- Acts (331)(1) := (use_clause_1'Access, null);
- Acts (331)(2) := (use_clause_2'Access, null);
- Acts (332).Set_First_Last (0, 3);
- Acts (332)(0) := (with_clause_0'Access, null);
- Acts (332)(1) := (with_clause_1'Access, null);
- Acts (332)(2) := (with_clause_2'Access, null);
- Acts (332)(3) := (with_clause_3'Access, null);
+ Acts (317)(0) := (task_body_0'Access, task_body_0_check'Access);
+ Acts (318).Set_First_Last (0, 0);
+ Acts (318)(0) := (task_body_stub_0'Access, null);
+ Acts (319).Set_First_Last (0, 1);
+ Acts (319)(0) := (task_definition_0'Access, null);
+ Acts (319)(1) := (task_definition_1'Access, null);
+ Acts (320).Set_First_Last (0, 2);
+ Acts (320)(0) := (task_type_declaration_0'Access,
task_type_declaration_0_check'Access);
+ Acts (320)(1) := (task_type_declaration_1'Access,
task_type_declaration_1_check'Access);
+ Acts (320)(2) := (task_type_declaration_2'Access, null);
+ Acts (324).Set_First_Last (0, 0);
+ Acts (324)(0) := (timed_entry_call_0'Access, null);
+ Acts (328).Set_First_Last (0, 0);
+ Acts (328)(0) := (variant_part_0'Access, null);
+ Acts (329).Set_First_Last (0, 1);
+ Acts (329)(0) := (variant_list_0'Access, null);
+ Acts (330).Set_First_Last (0, 0);
+ Acts (330)(0) := (variant_0'Access, null);
+ Acts (332).Set_First_Last (0, 2);
+ Acts (332)(0) := (use_clause_0'Access, null);
+ Acts (332)(1) := (use_clause_1'Access, null);
+ Acts (332)(2) := (use_clause_2'Access, null);
+ Acts (333).Set_First_Last (0, 3);
+ Acts (333)(0) := (with_clause_0'Access, null);
+ Acts (333)(1) := (with_clause_1'Access, null);
+ Acts (333)(2) := (with_clause_2'Access, null);
+ Acts (333)(3) := (with_clause_3'Access, null);
end return;
end Actions;
diff --git a/packages/ada-mode/ada_re2c.c b/packages/ada-mode/ada_re2c.c
index 3965021..6c79343 100644
--- a/packages/ada-mode/ada_re2c.c
+++ b/packages/ada-mode/ada_re2c.c
@@ -55,7 +55,7 @@ wisi_lexer* ada_new_lexer
result->buffer_last = input + length - 1;
result->cursor = input;
result->byte_token_start = input;
- result->char_pos = 1;
+ result->char_pos = 1; /* match WisiToken.Buffer_Region */
result->char_token_start = 1;
result->line = (*result->cursor == 0x0A) ? 2 : 1;
result->line_token_start = result->line;
@@ -93,16 +93,22 @@ static void debug(wisi_lexer* lexer, int state, unsigned
char ch)
#define YYPEEK() (lexer->cursor <= lexer->buffer_last) ? *lexer->cursor : 4
-#define DO_COUNT ((*lexer->cursor & 0xC0) != 0xC0) && (*lexer->cursor != 0x0D)
-
static void skip(wisi_lexer* lexer)
{
if (lexer->cursor <= lexer->buffer_last)
- {
++lexer->cursor;
- if (DO_COUNT) ++lexer->char_pos;
- if (lexer->cursor <= lexer->buffer_last)
- if (*lexer->cursor == 0x0A) ++lexer->line;
+ if (lexer->cursor <= lexer->buffer_last)
+ {
+ /* UFT-8 encoding: https://en.wikipedia.org/wiki/UTF-8#Description */
+ if (*lexer->cursor == 0x0A && lexer->cursor > lexer->buffer &&
*(lexer->cursor - 1) == 0x0D)
+ {/* second byte of DOS line ending */
+ }
+ else if ((*lexer->cursor & 0x80) == 0x80 && (*lexer->cursor & 0xC0) !=
0xC0)
+ {/* byte 2, 3 or 4 of multi-byte UTF-8 char */
+ }
+ else
+ ++lexer->char_pos;
+ if (*lexer->cursor == 0x0A) ++lexer->line;
}
}
#define YYSKIP() skip(lexer)
@@ -124,7 +130,7 @@ int ada_next_token
*id = -1;
if (lexer->cursor > lexer->buffer_last)
{
- *id = 107;
+ *id = 108;
*byte_position = lexer->buffer_last - lexer->buffer + 1;
*byte_length = 0;
*char_position = lexer->char_token_start;
@@ -143,7 +149,7 @@ int ada_next_token
while (*id == -1 && status == 0)
{
-#line 147 "../ada_re2c.c"
+#line 153 "../ada_re2c.c"
{
YYCTYPE yych;
unsigned int yyaccept = 0;
@@ -197,47 +203,48 @@ int ada_next_token
case '<': goto yy44;
case '=': goto yy46;
case '>': goto yy48;
+ case '@': goto yy50;
case 'A':
- case 'a': goto yy50;
+ case 'a': goto yy52;
case 'B':
- case 'b': goto yy51;
+ case 'b': goto yy53;
case 'C':
- case 'c': goto yy52;
+ case 'c': goto yy54;
case 'D':
- case 'd': goto yy53;
+ case 'd': goto yy55;
case 'E':
- case 'e': goto yy54;
+ case 'e': goto yy56;
case 'F':
- case 'f': goto yy55;
+ case 'f': goto yy57;
case 'G':
- case 'g': goto yy56;
+ case 'g': goto yy58;
case 'I':
- case 'i': goto yy57;
+ case 'i': goto yy59;
case 'L':
- case 'l': goto yy58;
+ case 'l': goto yy60;
case 'M':
- case 'm': goto yy59;
+ case 'm': goto yy61;
case 'N':
- case 'n': goto yy60;
+ case 'n': goto yy62;
case 'O':
- case 'o': goto yy61;
+ case 'o': goto yy63;
case 'P':
- case 'p': goto yy62;
+ case 'p': goto yy64;
case 'R':
- case 'r': goto yy63;
+ case 'r': goto yy65;
case 'S':
- case 's': goto yy64;
+ case 's': goto yy66;
case 'T':
- case 't': goto yy65;
+ case 't': goto yy67;
case 'U':
- case 'u': goto yy66;
+ case 'u': goto yy68;
case 'W':
- case 'w': goto yy67;
+ case 'w': goto yy69;
case 'X':
- case 'x': goto yy68;
- case '[': goto yy69;
- case '{': goto yy70;
- case '|': goto yy71;
+ case 'x': goto yy70;
+ case '[': goto yy71;
+ case '{': goto yy72;
+ case '|': goto yy73;
case 0xC2:
case 0xC3:
case 0xC4:
@@ -267,8 +274,8 @@ int ada_next_token
case 0xDC:
case 0xDD:
case 0xDE:
- case 0xDF: goto yy73;
- case 0xE0: goto yy74;
+ case 0xDF: goto yy75;
+ case 0xE0: goto yy76;
case 0xE1:
case 0xE2:
case 0xE3:
@@ -283,12 +290,12 @@ int ada_next_token
case 0xEC:
case 0xED:
case 0xEE:
- case 0xEF: goto yy75;
- case 0xF0: goto yy76;
+ case 0xEF: goto yy77;
+ case 0xF0: goto yy78;
case 0xF1:
case 0xF2:
- case 0xF3: goto yy77;
- case 0xF4: goto yy78;
+ case 0xF3: goto yy79;
+ case 0xF4: goto yy80;
default: goto yy2;
}
yy2:
@@ -296,16 +303,16 @@ yy2:
YYSKIP ();
yy3:
YYDEBUG(3, YYPEEK ());
-#line 369 "../ada.re2c"
+#line 377 "../ada.re2c"
{status = ERROR_unrecognized_character; continue;}
-#line 302 "../ada_re2c.c"
+#line 309 "../ada_re2c.c"
yy4:
YYDEBUG(4, YYPEEK ());
YYSKIP ();
YYDEBUG(5, YYPEEK ());
-#line 367 "../ada.re2c"
- {*id = 107; continue;}
-#line 309 "../ada_re2c.c"
+#line 375 "../ada.re2c"
+ {*id = 108; continue;}
+#line 316 "../ada_re2c.c"
yy6:
YYDEBUG(6, YYPEEK ());
YYSKIP ();
@@ -318,7 +325,7 @@ yy6:
}
yy8:
YYDEBUG(8, YYPEEK ());
-#line 254 "../ada.re2c"
+#line 261 "../ada.re2c"
{ lexer->byte_token_start = lexer->cursor;
lexer->char_token_start = lexer->char_pos;
if (*lexer->cursor == 0x0A)
@@ -326,14 +333,14 @@ yy8:
else
lexer->line_token_start = lexer->line;
continue; }
-#line 330 "../ada_re2c.c"
+#line 337 "../ada_re2c.c"
yy9:
YYDEBUG(9, YYPEEK ());
YYSKIP ();
YYDEBUG(10, YYPEEK ());
-#line 261 "../ada.re2c"
+#line 268 "../ada.re2c"
{*id = 1; continue;}
-#line 337 "../ada_re2c.c"
+#line 344 "../ada_re2c.c"
yy11:
YYDEBUG(11, YYPEEK ());
YYSKIP ();
@@ -495,7 +502,7 @@ yy12:
case 0xF1:
case 0xF2:
case 0xF3:
- case 0xF4: goto yy80;
+ case 0xF4: goto yy82;
default: goto yy3;
}
yy13:
@@ -505,8 +512,8 @@ yy13:
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
- case 'e': goto yy92;
- case 'i': goto yy93;
+ case 'e': goto yy94;
+ case 'i': goto yy95;
default: goto yy3;
}
yy14:
@@ -581,7 +588,7 @@ yy15:
case 'x':
case 'y':
case 'z': goto yy14;
- case '[': goto yy94;
+ case '[': goto yy96;
case 0xC2:
case 0xC3:
case 0xC4:
@@ -611,8 +618,8 @@ yy15:
case 0xDC:
case 0xDD:
case 0xDE:
- case 0xDF: goto yy95;
- case 0xE0: goto yy96;
+ case 0xDF: goto yy97;
+ case 0xE0: goto yy98;
case 0xE1:
case 0xE2:
case 0xE3:
@@ -627,26 +634,26 @@ yy15:
case 0xEC:
case 0xED:
case 0xEE:
- case 0xEF: goto yy97;
- case 0xF0: goto yy98;
+ case 0xEF: goto yy99;
+ case 0xF0: goto yy100;
case 0xF1:
case 0xF2:
- case 0xF3: goto yy99;
- case 0xF4: goto yy100;
+ case 0xF3: goto yy101;
+ case 0xF4: goto yy102;
default: goto yy16;
}
yy16:
YYDEBUG(16, YYPEEK ());
-#line 364 "../ada.re2c"
- {*id = 104; continue;}
-#line 643 "../ada_re2c.c"
+#line 372 "../ada.re2c"
+ {*id = 105; continue;}
+#line 650 "../ada_re2c.c"
yy17:
YYDEBUG(17, YYPEEK ());
YYSKIP ();
YYDEBUG(18, YYPEEK ());
-#line 338 "../ada.re2c"
+#line 345 "../ada.re2c"
{*id = 78; continue;}
-#line 650 "../ada_re2c.c"
+#line 657 "../ada_re2c.c"
yy19:
YYDEBUG(19, YYPEEK ());
yyaccept = 2;
@@ -747,11 +754,11 @@ yy19:
case '|':
case '}':
case '~':
- case 0x7F: goto yy101;
+ case 0x7F: goto yy103;
case '(':
YYBACKUPCTX ();
- goto yy102;
- case '[': goto yy103;
+ goto yy104;
+ case '[': goto yy105;
case 0xC2:
case 0xC3:
case 0xC4:
@@ -781,8 +788,8 @@ yy19:
case 0xDC:
case 0xDD:
case 0xDE:
- case 0xDF: goto yy104;
- case 0xE0: goto yy105;
+ case 0xDF: goto yy106;
+ case 0xE0: goto yy107;
case 0xE1:
case 0xE2:
case 0xE3:
@@ -797,99 +804,99 @@ yy19:
case 0xEC:
case 0xED:
case 0xEE:
- case 0xEF: goto yy106;
- case 0xF0: goto yy107;
+ case 0xEF: goto yy108;
+ case 0xF0: goto yy109;
case 0xF1:
case 0xF2:
- case 0xF3: goto yy108;
- case 0xF4: goto yy109;
+ case 0xF3: goto yy110;
+ case 0xF4: goto yy111;
default: goto yy20;
}
yy20:
YYDEBUG(20, YYPEEK ());
-#line 361 "../ada.re2c"
- {*id = 101; continue;}
-#line 813 "../ada_re2c.c"
+#line 369 "../ada.re2c"
+ {*id = 102; continue;}
+#line 820 "../ada_re2c.c"
yy21:
YYDEBUG(21, YYPEEK ());
YYSKIP ();
YYDEBUG(22, YYPEEK ());
-#line 336 "../ada.re2c"
+#line 343 "../ada.re2c"
{*id = 76; continue;}
-#line 820 "../ada_re2c.c"
+#line 827 "../ada_re2c.c"
yy23:
YYDEBUG(23, YYPEEK ());
YYSKIP ();
YYDEBUG(24, YYPEEK ());
-#line 337 "../ada.re2c"
+#line 344 "../ada.re2c"
{*id = 77; continue;}
-#line 827 "../ada_re2c.c"
+#line 834 "../ada_re2c.c"
yy25:
YYDEBUG(25, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
- case '*': goto yy110;
+ case '*': goto yy112;
default: goto yy26;
}
yy26:
YYDEBUG(26, YYPEEK ());
-#line 359 "../ada.re2c"
- {*id = 99; continue;}
-#line 840 "../ada_re2c.c"
+#line 367 "../ada.re2c"
+ {*id = 100; continue;}
+#line 847 "../ada_re2c.c"
yy27:
YYDEBUG(27, YYPEEK ());
YYSKIP ();
YYDEBUG(28, YYPEEK ());
-#line 355 "../ada.re2c"
- {*id = 95; continue;}
-#line 847 "../ada_re2c.c"
+#line 363 "../ada.re2c"
+ {*id = 96; continue;}
+#line 854 "../ada_re2c.c"
yy29:
YYDEBUG(29, YYPEEK ());
YYSKIP ();
YYDEBUG(30, YYPEEK ());
-#line 343 "../ada.re2c"
- {*id = 83; continue;}
-#line 854 "../ada_re2c.c"
+#line 351 "../ada.re2c"
+ {*id = 84; continue;}
+#line 861 "../ada_re2c.c"
yy31:
YYDEBUG(31, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
- case '-': goto yy112;
+ case '-': goto yy114;
default: goto yy32;
}
yy32:
YYDEBUG(32, YYPEEK ());
-#line 354 "../ada.re2c"
- {*id = 94; continue;}
-#line 867 "../ada_re2c.c"
+#line 362 "../ada.re2c"
+ {*id = 95; continue;}
+#line 874 "../ada_re2c.c"
yy33:
YYDEBUG(33, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
- case '.': goto yy115;
+ case '.': goto yy117;
default: goto yy34;
}
yy34:
YYDEBUG(34, YYPEEK ());
-#line 344 "../ada.re2c"
- {*id = 84; continue;}
-#line 880 "../ada_re2c.c"
+#line 352 "../ada.re2c"
+ {*id = 85; continue;}
+#line 887 "../ada_re2c.c"
yy35:
YYDEBUG(35, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
- case '=': goto yy117;
+ case '=': goto yy119;
default: goto yy36;
}
yy36:
YYDEBUG(36, YYPEEK ());
-#line 357 "../ada.re2c"
- {*id = 97; continue;}
-#line 893 "../ada_re2c.c"
+#line 365 "../ada.re2c"
+ {*id = 98; continue;}
+#line 900 "../ada_re2c.c"
yy37:
YYDEBUG(37, YYPEEK ());
yyaccept = 3;
@@ -898,12 +905,12 @@ yy37:
yych = YYPEEK ();
YYDEBUG(38, YYPEEK ());
switch (yych) {
- case '#': goto yy119;
+ case '#': goto yy121;
case '-':
case '.':
case 'E':
case '_':
- case 'e': goto yy120;
+ case 'e': goto yy122;
case '0':
case '1':
case '2':
@@ -918,356 +925,363 @@ yy37:
}
yy39:
YYDEBUG(39, YYPEEK ());
-#line 363 "../ada.re2c"
- {*id = 103; continue;}
-#line 924 "../ada_re2c.c"
+#line 371 "../ada.re2c"
+ {*id = 104; continue;}
+#line 931 "../ada_re2c.c"
yy40:
YYDEBUG(40, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
- case '=': goto yy122;
+ case '=': goto yy124;
default: goto yy41;
}
yy41:
YYDEBUG(41, YYPEEK ());
-#line 341 "../ada.re2c"
- {*id = 81; continue;}
-#line 937 "../ada_re2c.c"
+#line 349 "../ada.re2c"
+ {*id = 82; continue;}
+#line 944 "../ada_re2c.c"
yy42:
YYDEBUG(42, YYPEEK ());
YYSKIP ();
YYDEBUG(43, YYPEEK ());
-#line 356 "../ada.re2c"
- {*id = 96; continue;}
-#line 944 "../ada_re2c.c"
+#line 364 "../ada.re2c"
+ {*id = 97; continue;}
+#line 951 "../ada_re2c.c"
yy44:
YYDEBUG(44, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
- case '<': goto yy124;
- case '=': goto yy126;
- case '>': goto yy128;
+ case '<': goto yy126;
+ case '=': goto yy128;
+ case '>': goto yy130;
default: goto yy45;
}
yy45:
YYDEBUG(45, YYPEEK ());
-#line 351 "../ada.re2c"
- {*id = 91; continue;}
-#line 959 "../ada_re2c.c"
+#line 359 "../ada.re2c"
+ {*id = 92; continue;}
+#line 966 "../ada_re2c.c"
yy46:
YYDEBUG(46, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
- case '>': goto yy130;
+ case '>': goto yy132;
default: goto yy47;
}
yy47:
YYDEBUG(47, YYPEEK ());
-#line 346 "../ada.re2c"
- {*id = 86; continue;}
-#line 972 "../ada_re2c.c"
+#line 354 "../ada.re2c"
+ {*id = 87; continue;}
+#line 979 "../ada_re2c.c"
yy48:
YYDEBUG(48, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
- case '=': goto yy132;
- case '>': goto yy134;
+ case '=': goto yy134;
+ case '>': goto yy136;
default: goto yy49;
}
yy49:
YYDEBUG(49, YYPEEK ());
-#line 348 "../ada.re2c"
- {*id = 88; continue;}
-#line 986 "../ada_re2c.c"
+#line 356 "../ada.re2c"
+ {*id = 89; continue;}
+#line 993 "../ada_re2c.c"
yy50:
YYDEBUG(50, YYPEEK ());
+ YYSKIP ();
+ YYDEBUG(51, YYPEEK ());
+#line 346 "../ada.re2c"
+ {*id = 79; continue;}
+#line 1000 "../ada_re2c.c"
+yy52:
+ YYDEBUG(52, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'B':
- case 'b': goto yy136;
+ case 'b': goto yy138;
case 'C':
- case 'c': goto yy137;
+ case 'c': goto yy139;
case 'L':
- case 'l': goto yy138;
+ case 'l': goto yy140;
case 'N':
- case 'n': goto yy139;
+ case 'n': goto yy141;
case 'R':
- case 'r': goto yy140;
+ case 'r': goto yy142;
case 'T':
- case 't': goto yy141;
+ case 't': goto yy143;
default: goto yy15;
}
-yy51:
- YYDEBUG(51, YYPEEK ());
+yy53:
+ YYDEBUG(53, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy143;
+ case 'e': goto yy145;
case 'O':
- case 'o': goto yy144;
+ case 'o': goto yy146;
default: goto yy15;
}
-yy52:
- YYDEBUG(52, YYPEEK ());
+yy54:
+ YYDEBUG(54, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'A':
- case 'a': goto yy145;
+ case 'a': goto yy147;
case 'O':
- case 'o': goto yy146;
+ case 'o': goto yy148;
default: goto yy15;
}
-yy53:
- YYDEBUG(53, YYPEEK ());
+yy55:
+ YYDEBUG(55, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy147;
+ case 'e': goto yy149;
case 'I':
- case 'i': goto yy148;
+ case 'i': goto yy150;
case 'O':
- case 'o': goto yy149;
+ case 'o': goto yy151;
default: goto yy15;
}
-yy54:
- YYDEBUG(54, YYPEEK ());
+yy56:
+ YYDEBUG(56, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'L':
- case 'l': goto yy151;
+ case 'l': goto yy153;
case 'N':
- case 'n': goto yy152;
+ case 'n': goto yy154;
case 'X':
- case 'x': goto yy153;
+ case 'x': goto yy155;
default: goto yy15;
}
-yy55:
- YYDEBUG(55, YYPEEK ());
+yy57:
+ YYDEBUG(57, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'O':
- case 'o': goto yy154;
+ case 'o': goto yy156;
case 'U':
- case 'u': goto yy155;
+ case 'u': goto yy157;
default: goto yy15;
}
-yy56:
- YYDEBUG(56, YYPEEK ());
+yy58:
+ YYDEBUG(58, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy156;
+ case 'e': goto yy158;
case 'O':
- case 'o': goto yy157;
+ case 'o': goto yy159;
default: goto yy15;
}
-yy57:
- YYDEBUG(57, YYPEEK ());
+yy59:
+ YYDEBUG(59, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'F':
- case 'f': goto yy158;
+ case 'f': goto yy160;
case 'N':
- case 'n': goto yy160;
+ case 'n': goto yy162;
case 'S':
- case 's': goto yy162;
+ case 's': goto yy164;
default: goto yy15;
}
-yy58:
- YYDEBUG(58, YYPEEK ());
+yy60:
+ YYDEBUG(60, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'I':
- case 'i': goto yy164;
+ case 'i': goto yy166;
case 'O':
- case 'o': goto yy165;
+ case 'o': goto yy167;
default: goto yy15;
}
-yy59:
- YYDEBUG(59, YYPEEK ());
+yy61:
+ YYDEBUG(61, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'O':
- case 'o': goto yy166;
+ case 'o': goto yy168;
default: goto yy15;
}
-yy60:
- YYDEBUG(60, YYPEEK ());
+yy62:
+ YYDEBUG(62, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy167;
+ case 'e': goto yy169;
case 'O':
- case 'o': goto yy168;
+ case 'o': goto yy170;
case 'U':
- case 'u': goto yy169;
+ case 'u': goto yy171;
default: goto yy15;
}
-yy61:
- YYDEBUG(61, YYPEEK ());
+yy63:
+ YYDEBUG(63, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'F':
- case 'f': goto yy170;
+ case 'f': goto yy172;
case 'R':
- case 'r': goto yy172;
+ case 'r': goto yy174;
case 'T':
- case 't': goto yy174;
+ case 't': goto yy176;
case 'U':
- case 'u': goto yy175;
+ case 'u': goto yy177;
case 'V':
- case 'v': goto yy176;
+ case 'v': goto yy178;
default: goto yy15;
}
-yy62:
- YYDEBUG(62, YYPEEK ());
+yy64:
+ YYDEBUG(64, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'A':
- case 'a': goto yy177;
+ case 'a': goto yy179;
case 'R':
- case 'r': goto yy178;
+ case 'r': goto yy180;
default: goto yy15;
}
-yy63:
- YYDEBUG(63, YYPEEK ());
+yy65:
+ YYDEBUG(65, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'A':
- case 'a': goto yy179;
+ case 'a': goto yy181;
case 'E':
- case 'e': goto yy180;
+ case 'e': goto yy182;
default: goto yy15;
}
-yy64:
- YYDEBUG(64, YYPEEK ());
+yy66:
+ YYDEBUG(66, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy181;
+ case 'e': goto yy183;
case 'O':
- case 'o': goto yy182;
+ case 'o': goto yy184;
case 'U':
- case 'u': goto yy183;
+ case 'u': goto yy185;
case 'Y':
- case 'y': goto yy184;
+ case 'y': goto yy186;
default: goto yy15;
}
-yy65:
- YYDEBUG(65, YYPEEK ());
+yy67:
+ YYDEBUG(67, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'A':
- case 'a': goto yy185;
+ case 'a': goto yy187;
case 'E':
- case 'e': goto yy186;
+ case 'e': goto yy188;
case 'H':
- case 'h': goto yy187;
+ case 'h': goto yy189;
case 'Y':
- case 'y': goto yy188;
+ case 'y': goto yy190;
default: goto yy15;
}
-yy66:
- YYDEBUG(66, YYPEEK ());
+yy68:
+ YYDEBUG(68, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'N':
- case 'n': goto yy189;
+ case 'n': goto yy191;
case 'S':
- case 's': goto yy190;
+ case 's': goto yy192;
default: goto yy15;
}
-yy67:
- YYDEBUG(67, YYPEEK ());
+yy69:
+ YYDEBUG(69, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'H':
- case 'h': goto yy191;
+ case 'h': goto yy193;
case 'I':
- case 'i': goto yy192;
+ case 'i': goto yy194;
default: goto yy15;
}
-yy68:
- YYDEBUG(68, YYPEEK ());
+yy70:
+ YYDEBUG(70, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'O':
- case 'o': goto yy193;
+ case 'o': goto yy195;
default: goto yy15;
}
-yy69:
- YYDEBUG(69, YYPEEK ());
+yy71:
+ YYDEBUG(71, YYPEEK ());
yyaccept = 0;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
- case '"': goto yy194;
+ case '"': goto yy196;
default: goto yy3;
}
-yy70:
- YYDEBUG(70, YYPEEK ());
+yy72:
+ YYDEBUG(72, YYPEEK ());
yyaccept = 0;
YYSKIP ();
YYBACKUP ();
@@ -1451,19 +1465,19 @@ yy70:
case 0xF1:
case 0xF2:
case 0xF3:
- case 0xF4: goto yy196;
+ case 0xF4: goto yy198;
default: goto yy3;
}
-yy71:
- YYDEBUG(71, YYPEEK ());
- YYSKIP ();
- YYDEBUG(72, YYPEEK ());
-#line 339 "../ada.re2c"
- {*id = 79; continue;}
-#line 1464 "../ada_re2c.c"
yy73:
YYDEBUG(73, YYPEEK ());
YYSKIP ();
+ YYDEBUG(74, YYPEEK ());
+#line 347 "../ada.re2c"
+ {*id = 80; continue;}
+#line 1478 "../ada_re2c.c"
+yy75:
+ YYDEBUG(75, YYPEEK ());
+ YYSKIP ();
yych = YYPEEK ();
switch (yych) {
case 0x80:
@@ -1532,8 +1546,8 @@ yy73:
case 0xBF: goto yy14;
default: goto yy3;
}
-yy74:
- YYDEBUG(74, YYPEEK ());
+yy76:
+ YYDEBUG(76, YYPEEK ());
yyaccept = 0;
YYSKIP ();
YYBACKUP ();
@@ -1570,11 +1584,11 @@ yy74:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy95;
+ case 0xBF: goto yy97;
default: goto yy3;
}
-yy75:
- YYDEBUG(75, YYPEEK ());
+yy77:
+ YYDEBUG(77, YYPEEK ());
yyaccept = 0;
YYSKIP ();
YYBACKUP ();
@@ -1643,11 +1657,11 @@ yy75:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy95;
+ case 0xBF: goto yy97;
default: goto yy3;
}
-yy76:
- YYDEBUG(76, YYPEEK ());
+yy78:
+ YYDEBUG(78, YYPEEK ());
yyaccept = 0;
YYSKIP ();
YYBACKUP ();
@@ -1700,11 +1714,11 @@ yy76:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy97;
+ case 0xBF: goto yy99;
default: goto yy3;
}
-yy77:
- YYDEBUG(77, YYPEEK ());
+yy79:
+ YYDEBUG(79, YYPEEK ());
yyaccept = 0;
YYSKIP ();
YYBACKUP ();
@@ -1773,11 +1787,11 @@ yy77:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy97;
+ case 0xBF: goto yy99;
default: goto yy3;
}
-yy78:
- YYDEBUG(78, YYPEEK ());
+yy80:
+ YYDEBUG(80, YYPEEK ());
yyaccept = 0;
YYSKIP ();
YYBACKUP ();
@@ -1798,15 +1812,15 @@ yy78:
case 0x8C:
case 0x8D:
case 0x8E:
- case 0x8F: goto yy97;
+ case 0x8F: goto yy99;
default: goto yy3;
}
-yy79:
- YYDEBUG(79, YYPEEK ());
+yy81:
+ YYDEBUG(81, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
-yy80:
- YYDEBUG(80, YYPEEK ());
+yy82:
+ YYDEBUG(82, YYPEEK ());
switch (yych) {
case ' ':
case '!':
@@ -1901,9 +1915,9 @@ yy80:
case '|':
case '}':
case '~':
- case 0x7F: goto yy79;
- case '"': goto yy82;
- case '[': goto yy84;
+ case 0x7F: goto yy81;
+ case '"': goto yy84;
+ case '[': goto yy86;
case 0xC2:
case 0xC3:
case 0xC4:
@@ -1933,8 +1947,8 @@ yy80:
case 0xDC:
case 0xDD:
case 0xDE:
- case 0xDF: goto yy86;
- case 0xE0: goto yy87;
+ case 0xDF: goto yy88;
+ case 0xE0: goto yy89;
case 0xE1:
case 0xE2:
case 0xE3:
@@ -1949,119 +1963,119 @@ yy80:
case 0xEC:
case 0xED:
case 0xEE:
- case 0xEF: goto yy88;
- case 0xF0: goto yy89;
+ case 0xEF: goto yy90;
+ case 0xF0: goto yy91;
case 0xF1:
case 0xF2:
- case 0xF3: goto yy90;
- case 0xF4: goto yy91;
- default: goto yy81;
+ case 0xF3: goto yy92;
+ case 0xF4: goto yy93;
+ default: goto yy83;
}
-yy81:
- YYDEBUG(81, YYPEEK ());
+yy83:
+ YYDEBUG(83, YYPEEK ());
YYRESTORE ();
switch (yyaccept) {
case 0: goto yy3;
case 1: goto yy16;
case 2: goto yy20;
case 3: goto yy39;
- case 4: goto yy83;
- case 5: goto yy114;
- case 6: goto yy142;
- case 7: goto yy150;
- case 8: goto yy159;
- case 9: goto yy161;
- case 10: goto yy163;
- case 11: goto yy171;
- case 12: goto yy173;
- case 13: goto yy208;
- case 14: goto yy223;
- case 15: goto yy227;
- case 16: goto yy229;
- case 17: goto yy240;
- case 18: goto yy245;
- case 19: goto yy253;
- case 20: goto yy255;
- case 21: goto yy257;
- case 22: goto yy261;
- case 23: goto yy271;
- case 24: goto yy288;
- case 25: goto yy293;
- case 26: goto yy317;
- case 27: goto yy319;
- case 28: goto yy326;
- case 29: goto yy331;
- case 30: goto yy335;
- case 31: goto yy339;
- case 32: goto yy341;
- case 33: goto yy359;
- case 34: goto yy364;
- case 35: goto yy367;
- case 36: goto yy369;
- case 37: goto yy372;
- case 38: goto yy375;
- case 39: goto yy383;
- case 40: goto yy389;
- case 41: goto yy391;
- case 42: goto yy395;
- case 43: goto yy397;
- case 44: goto yy400;
- case 45: goto yy402;
- case 46: goto yy416;
- case 47: goto yy418;
- case 48: goto yy431;
- case 49: goto yy433;
- case 50: goto yy438;
- case 51: goto yy440;
- case 52: goto yy445;
- case 53: goto yy452;
- case 54: goto yy456;
- case 55: goto yy461;
- case 56: goto yy465;
- case 57: goto yy468;
- case 58: goto yy473;
- case 59: goto yy478;
- case 60: goto yy481;
- case 61: goto yy485;
- case 62: goto yy488;
- case 63: goto yy491;
- case 64: goto yy493;
- case 65: goto yy497;
- case 66: goto yy499;
- case 67: goto yy501;
- case 68: goto yy504;
- case 69: goto yy508;
- case 70: goto yy510;
- case 71: goto yy513;
- case 72: goto yy519;
- case 73: goto yy523;
- case 74: goto yy525;
- case 75: goto yy528;
- case 76: goto yy530;
- case 77: goto yy533;
- case 78: goto yy535;
- default: goto yy539;
+ case 4: goto yy85;
+ case 5: goto yy116;
+ case 6: goto yy144;
+ case 7: goto yy152;
+ case 8: goto yy161;
+ case 9: goto yy163;
+ case 10: goto yy165;
+ case 11: goto yy173;
+ case 12: goto yy175;
+ case 13: goto yy210;
+ case 14: goto yy225;
+ case 15: goto yy229;
+ case 16: goto yy231;
+ case 17: goto yy242;
+ case 18: goto yy247;
+ case 19: goto yy255;
+ case 20: goto yy257;
+ case 21: goto yy259;
+ case 22: goto yy263;
+ case 23: goto yy273;
+ case 24: goto yy290;
+ case 25: goto yy295;
+ case 26: goto yy319;
+ case 27: goto yy321;
+ case 28: goto yy328;
+ case 29: goto yy333;
+ case 30: goto yy337;
+ case 31: goto yy341;
+ case 32: goto yy343;
+ case 33: goto yy361;
+ case 34: goto yy366;
+ case 35: goto yy369;
+ case 36: goto yy371;
+ case 37: goto yy374;
+ case 38: goto yy377;
+ case 39: goto yy385;
+ case 40: goto yy391;
+ case 41: goto yy393;
+ case 42: goto yy397;
+ case 43: goto yy399;
+ case 44: goto yy402;
+ case 45: goto yy404;
+ case 46: goto yy418;
+ case 47: goto yy420;
+ case 48: goto yy433;
+ case 49: goto yy435;
+ case 50: goto yy440;
+ case 51: goto yy442;
+ case 52: goto yy447;
+ case 53: goto yy454;
+ case 54: goto yy458;
+ case 55: goto yy463;
+ case 56: goto yy467;
+ case 57: goto yy470;
+ case 58: goto yy475;
+ case 59: goto yy480;
+ case 60: goto yy483;
+ case 61: goto yy487;
+ case 62: goto yy490;
+ case 63: goto yy493;
+ case 64: goto yy495;
+ case 65: goto yy499;
+ case 66: goto yy501;
+ case 67: goto yy503;
+ case 68: goto yy506;
+ case 69: goto yy510;
+ case 70: goto yy512;
+ case 71: goto yy515;
+ case 72: goto yy521;
+ case 73: goto yy525;
+ case 74: goto yy527;
+ case 75: goto yy530;
+ case 76: goto yy532;
+ case 77: goto yy535;
+ case 78: goto yy537;
+ default: goto yy541;
}
-yy82:
- YYDEBUG(82, YYPEEK ());
+yy84:
+ YYDEBUG(84, YYPEEK ());
yyaccept = 4;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
- case '"': goto yy79;
- default: goto yy83;
+ case '"': goto yy81;
+ default: goto yy85;
}
-yy83:
- YYDEBUG(83, YYPEEK ());
-#line 365 "../ada.re2c"
- {*id = 105; continue;}
-#line 2060 "../ada_re2c.c"
-yy84:
- YYDEBUG(84, YYPEEK ());
+yy85:
+ YYDEBUG(85, YYPEEK ());
+#line 373 "../ada.re2c"
+ {*id = 106; continue;}
+#line 2074 "../ada_re2c.c"
+yy86:
+ YYDEBUG(86, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
- YYDEBUG(85, YYPEEK ());
+ YYDEBUG(87, YYPEEK ());
switch (yych) {
case ' ':
case '!':
@@ -2156,9 +2170,9 @@ yy84:
case '|':
case '}':
case '~':
- case 0x7F: goto yy79;
- case '"': goto yy204;
- case '[': goto yy84;
+ case 0x7F: goto yy81;
+ case '"': goto yy206;
+ case '[': goto yy86;
case 0xC2:
case 0xC3:
case 0xC4:
@@ -2188,8 +2202,8 @@ yy84:
case 0xDC:
case 0xDD:
case 0xDE:
- case 0xDF: goto yy86;
- case 0xE0: goto yy87;
+ case 0xDF: goto yy88;
+ case 0xE0: goto yy89;
case 0xE1:
case 0xE2:
case 0xE3:
@@ -2204,16 +2218,16 @@ yy84:
case 0xEC:
case 0xED:
case 0xEE:
- case 0xEF: goto yy88;
- case 0xF0: goto yy89;
+ case 0xEF: goto yy90;
+ case 0xF0: goto yy91;
case 0xF1:
case 0xF2:
- case 0xF3: goto yy90;
- case 0xF4: goto yy91;
- default: goto yy81;
+ case 0xF3: goto yy92;
+ case 0xF4: goto yy93;
+ default: goto yy83;
}
-yy86:
- YYDEBUG(86, YYPEEK ());
+yy88:
+ YYDEBUG(88, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -2280,11 +2294,11 @@ yy86:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy79;
- default: goto yy81;
+ case 0xBF: goto yy81;
+ default: goto yy83;
}
-yy87:
- YYDEBUG(87, YYPEEK ());
+yy89:
+ YYDEBUG(89, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -2319,11 +2333,11 @@ yy87:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy86;
- default: goto yy81;
+ case 0xBF: goto yy88;
+ default: goto yy83;
}
-yy88:
- YYDEBUG(88, YYPEEK ());
+yy90:
+ YYDEBUG(90, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -2390,11 +2404,11 @@ yy88:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy86;
- default: goto yy81;
+ case 0xBF: goto yy88;
+ default: goto yy83;
}
-yy89:
- YYDEBUG(89, YYPEEK ());
+yy91:
+ YYDEBUG(91, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -2445,11 +2459,11 @@ yy89:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy88;
- default: goto yy81;
+ case 0xBF: goto yy90;
+ default: goto yy83;
}
-yy90:
- YYDEBUG(90, YYPEEK ());
+yy92:
+ YYDEBUG(92, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -2516,11 +2530,11 @@ yy90:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy88;
- default: goto yy81;
+ case 0xBF: goto yy90;
+ default: goto yy83;
}
-yy91:
- YYDEBUG(91, YYPEEK ());
+yy93:
+ YYDEBUG(93, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -2539,36 +2553,36 @@ yy91:
case 0x8C:
case 0x8D:
case 0x8E:
- case 0x8F: goto yy88;
- default: goto yy81;
+ case 0x8F: goto yy90;
+ default: goto yy83;
}
-yy92:
- YYDEBUG(92, YYPEEK ());
+yy94:
+ YYDEBUG(94, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
- case 'l': goto yy205;
- case 'n': goto yy206;
- default: goto yy81;
+ case 'l': goto yy207;
+ case 'n': goto yy208;
+ default: goto yy83;
}
-yy93:
- YYDEBUG(93, YYPEEK ());
+yy95:
+ YYDEBUG(95, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
- case 'f': goto yy112;
- default: goto yy81;
+ case 'f': goto yy114;
+ default: goto yy83;
}
-yy94:
- YYDEBUG(94, YYPEEK ());
+yy96:
+ YYDEBUG(96, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
- case '"': goto yy194;
- default: goto yy81;
+ case '"': goto yy196;
+ default: goto yy83;
}
-yy95:
- YYDEBUG(95, YYPEEK ());
+yy97:
+ YYDEBUG(97, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -2636,10 +2650,10 @@ yy95:
case 0xBD:
case 0xBE:
case 0xBF: goto yy14;
- default: goto yy81;
+ default: goto yy83;
}
-yy96:
- YYDEBUG(96, YYPEEK ());
+yy98:
+ YYDEBUG(98, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -2674,11 +2688,11 @@ yy96:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy95;
- default: goto yy81;
+ case 0xBF: goto yy97;
+ default: goto yy83;
}
-yy97:
- YYDEBUG(97, YYPEEK ());
+yy99:
+ YYDEBUG(99, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -2745,11 +2759,11 @@ yy97:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy95;
- default: goto yy81;
+ case 0xBF: goto yy97;
+ default: goto yy83;
}
-yy98:
- YYDEBUG(98, YYPEEK ());
+yy100:
+ YYDEBUG(100, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -2800,11 +2814,11 @@ yy98:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy97;
- default: goto yy81;
+ case 0xBF: goto yy99;
+ default: goto yy83;
}
-yy99:
- YYDEBUG(99, YYPEEK ());
+yy101:
+ YYDEBUG(101, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -2871,11 +2885,11 @@ yy99:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy97;
- default: goto yy81;
+ case 0xBF: goto yy99;
+ default: goto yy83;
}
-yy100:
- YYDEBUG(100, YYPEEK ());
+yy102:
+ YYDEBUG(102, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -2894,36 +2908,36 @@ yy100:
case 0x8C:
case 0x8D:
case 0x8E:
- case 0x8F: goto yy97;
- default: goto yy81;
+ case 0x8F: goto yy99;
+ default: goto yy83;
}
-yy101:
- YYDEBUG(101, YYPEEK ());
+yy103:
+ YYDEBUG(103, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
- case '\'': goto yy207;
- default: goto yy81;
+ case '\'': goto yy209;
+ default: goto yy83;
}
-yy102:
- YYDEBUG(102, YYPEEK ());
+yy104:
+ YYDEBUG(104, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
- case '\'': goto yy209;
- default: goto yy81;
+ case '\'': goto yy211;
+ default: goto yy83;
}
-yy103:
- YYDEBUG(103, YYPEEK ());
+yy105:
+ YYDEBUG(105, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
- case '"': goto yy210;
- case '\'': goto yy207;
- default: goto yy81;
+ case '"': goto yy212;
+ case '\'': goto yy209;
+ default: goto yy83;
}
-yy104:
- YYDEBUG(104, YYPEEK ());
+yy106:
+ YYDEBUG(106, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -2990,11 +3004,11 @@ yy104:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy101;
- default: goto yy81;
+ case 0xBF: goto yy103;
+ default: goto yy83;
}
-yy105:
- YYDEBUG(105, YYPEEK ());
+yy107:
+ YYDEBUG(107, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -3029,11 +3043,11 @@ yy105:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy104;
- default: goto yy81;
+ case 0xBF: goto yy106;
+ default: goto yy83;
}
-yy106:
- YYDEBUG(106, YYPEEK ());
+yy108:
+ YYDEBUG(108, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -3100,11 +3114,11 @@ yy106:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy104;
- default: goto yy81;
+ case 0xBF: goto yy106;
+ default: goto yy83;
}
-yy107:
- YYDEBUG(107, YYPEEK ());
+yy109:
+ YYDEBUG(109, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -3155,11 +3169,11 @@ yy107:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy106;
- default: goto yy81;
+ case 0xBF: goto yy108;
+ default: goto yy83;
}
-yy108:
- YYDEBUG(108, YYPEEK ());
+yy110:
+ YYDEBUG(110, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -3226,11 +3240,11 @@ yy108:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy106;
- default: goto yy81;
+ case 0xBF: goto yy108;
+ default: goto yy83;
}
-yy109:
- YYDEBUG(109, YYPEEK ());
+yy111:
+ YYDEBUG(111, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -3249,23 +3263,23 @@ yy109:
case 0x8C:
case 0x8D:
case 0x8E:
- case 0x8F: goto yy106;
- default: goto yy81;
+ case 0x8F: goto yy108;
+ default: goto yy83;
}
-yy110:
- YYDEBUG(110, YYPEEK ());
- YYSKIP ();
- YYDEBUG(111, YYPEEK ());
-#line 360 "../ada.re2c"
- {*id = 100; continue;}
-#line 3262 "../ada_re2c.c"
yy112:
YYDEBUG(112, YYPEEK ());
+ YYSKIP ();
+ YYDEBUG(113, YYPEEK ());
+#line 368 "../ada.re2c"
+ {*id = 101; continue;}
+#line 3276 "../ada_re2c.c"
+yy114:
+ YYDEBUG(114, YYPEEK ());
yyaccept = 5;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
- YYDEBUG(113, YYPEEK ());
+ YYDEBUG(115, YYPEEK ());
switch (yych) {
case 0x00:
case 0x01:
@@ -3392,7 +3406,7 @@ yy112:
case '|':
case '}':
case '~':
- case 0x7F: goto yy112;
+ case 0x7F: goto yy114;
case 0xC2:
case 0xC3:
case 0xC4:
@@ -3422,8 +3436,8 @@ yy112:
case 0xDC:
case 0xDD:
case 0xDE:
- case 0xDF: goto yy211;
- case 0xE0: goto yy212;
+ case 0xDF: goto yy213;
+ case 0xE0: goto yy214;
case 0xE1:
case 0xE2:
case 0xE3:
@@ -3438,52 +3452,52 @@ yy112:
case 0xEC:
case 0xED:
case 0xEE:
- case 0xEF: goto yy213;
- case 0xF0: goto yy214;
+ case 0xEF: goto yy215;
+ case 0xF0: goto yy216;
case 0xF1:
case 0xF2:
- case 0xF3: goto yy215;
- case 0xF4: goto yy216;
- default: goto yy114;
+ case 0xF3: goto yy217;
+ case 0xF4: goto yy218;
+ default: goto yy116;
}
-yy114:
- YYDEBUG(114, YYPEEK ());
-#line 262 "../ada.re2c"
- {*id = 2; continue;}
-#line 3454 "../ada_re2c.c"
-yy115:
- YYDEBUG(115, YYPEEK ());
- YYSKIP ();
+yy116:
YYDEBUG(116, YYPEEK ());
-#line 345 "../ada.re2c"
- {*id = 85; continue;}
-#line 3461 "../ada_re2c.c"
+#line 269 "../ada.re2c"
+ {*id = 2; continue;}
+#line 3468 "../ada_re2c.c"
yy117:
YYDEBUG(117, YYPEEK ());
YYSKIP ();
YYDEBUG(118, YYPEEK ());
-#line 358 "../ada.re2c"
- {*id = 98; continue;}
-#line 3468 "../ada_re2c.c"
+#line 353 "../ada.re2c"
+ {*id = 86; continue;}
+#line 3475 "../ada_re2c.c"
yy119:
YYDEBUG(119, YYPEEK ());
YYSKIP ();
+ YYDEBUG(120, YYPEEK ());
+#line 366 "../ada.re2c"
+ {*id = 99; continue;}
+#line 3482 "../ada_re2c.c"
+yy121:
+ YYDEBUG(121, YYPEEK ());
+ YYSKIP ();
yych = YYPEEK ();
switch (yych) {
- case '#': goto yy81;
- default: goto yy218;
+ case '#': goto yy83;
+ default: goto yy220;
}
-yy120:
- YYDEBUG(120, YYPEEK ());
+yy122:
+ YYDEBUG(122, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
- YYDEBUG(121, YYPEEK ());
+ YYDEBUG(123, YYPEEK ());
switch (yych) {
case '-':
case '.':
case 'E':
case '_':
- case 'e': goto yy120;
+ case 'e': goto yy122;
case '0':
case '1':
case '2':
@@ -3493,119 +3507,119 @@ yy120:
case '6':
case '7':
case '8':
- case '9': goto yy219;
- default: goto yy81;
+ case '9': goto yy221;
+ default: goto yy83;
}
-yy122:
- YYDEBUG(122, YYPEEK ());
- YYSKIP ();
- YYDEBUG(123, YYPEEK ());
-#line 342 "../ada.re2c"
- {*id = 82; continue;}
-#line 3506 "../ada_re2c.c"
yy124:
YYDEBUG(124, YYPEEK ());
YYSKIP ();
YYDEBUG(125, YYPEEK ());
-#line 353 "../ada.re2c"
- {*id = 93; continue;}
-#line 3513 "../ada_re2c.c"
+#line 350 "../ada.re2c"
+ {*id = 83; continue;}
+#line 3520 "../ada_re2c.c"
yy126:
YYDEBUG(126, YYPEEK ());
YYSKIP ();
YYDEBUG(127, YYPEEK ());
-#line 352 "../ada.re2c"
- {*id = 92; continue;}
-#line 3520 "../ada_re2c.c"
+#line 361 "../ada.re2c"
+ {*id = 94; continue;}
+#line 3527 "../ada_re2c.c"
yy128:
YYDEBUG(128, YYPEEK ());
YYSKIP ();
YYDEBUG(129, YYPEEK ());
-#line 340 "../ada.re2c"
- {*id = 80; continue;}
-#line 3527 "../ada_re2c.c"
+#line 360 "../ada.re2c"
+ {*id = 93; continue;}
+#line 3534 "../ada_re2c.c"
yy130:
YYDEBUG(130, YYPEEK ());
YYSKIP ();
YYDEBUG(131, YYPEEK ());
-#line 347 "../ada.re2c"
- {*id = 87; continue;}
-#line 3534 "../ada_re2c.c"
+#line 348 "../ada.re2c"
+ {*id = 81; continue;}
+#line 3541 "../ada_re2c.c"
yy132:
YYDEBUG(132, YYPEEK ());
YYSKIP ();
YYDEBUG(133, YYPEEK ());
-#line 349 "../ada.re2c"
- {*id = 89; continue;}
-#line 3541 "../ada_re2c.c"
+#line 355 "../ada.re2c"
+ {*id = 88; continue;}
+#line 3548 "../ada_re2c.c"
yy134:
YYDEBUG(134, YYPEEK ());
YYSKIP ();
YYDEBUG(135, YYPEEK ());
-#line 350 "../ada.re2c"
+#line 357 "../ada.re2c"
{*id = 90; continue;}
-#line 3548 "../ada_re2c.c"
+#line 3555 "../ada_re2c.c"
yy136:
YYDEBUG(136, YYPEEK ());
+ YYSKIP ();
+ YYDEBUG(137, YYPEEK ());
+#line 358 "../ada.re2c"
+ {*id = 91; continue;}
+#line 3562 "../ada_re2c.c"
+yy138:
+ YYDEBUG(138, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'O':
- case 'o': goto yy221;
+ case 'o': goto yy223;
case 'S':
- case 's': goto yy222;
+ case 's': goto yy224;
default: goto yy15;
}
-yy137:
- YYDEBUG(137, YYPEEK ());
+yy139:
+ YYDEBUG(139, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'C':
- case 'c': goto yy224;
+ case 'c': goto yy226;
default: goto yy15;
}
-yy138:
- YYDEBUG(138, YYPEEK ());
+yy140:
+ YYDEBUG(140, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'I':
- case 'i': goto yy225;
+ case 'i': goto yy227;
case 'L':
- case 'l': goto yy226;
+ case 'l': goto yy228;
default: goto yy15;
}
-yy139:
- YYDEBUG(139, YYPEEK ());
+yy141:
+ YYDEBUG(141, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'D':
- case 'd': goto yy228;
+ case 'd': goto yy230;
default: goto yy15;
}
-yy140:
- YYDEBUG(140, YYPEEK ());
+yy142:
+ YYDEBUG(142, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'R':
- case 'r': goto yy230;
+ case 'r': goto yy232;
default: goto yy15;
}
-yy141:
- YYDEBUG(141, YYPEEK ());
+yy143:
+ YYDEBUG(143, YYPEEK ());
yyaccept = 6;
YYSKIP ();
YYBACKUP ();
@@ -3726,83 +3740,83 @@ yy141:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy142;
+ default: goto yy144;
}
-yy142:
- YYDEBUG(142, YYPEEK ());
-#line 272 "../ada.re2c"
+yy144:
+ YYDEBUG(144, YYPEEK ());
+#line 279 "../ada.re2c"
{*id = 12; continue;}
-#line 3736 "../ada_re2c.c"
-yy143:
- YYDEBUG(143, YYPEEK ());
+#line 3750 "../ada_re2c.c"
+yy145:
+ YYDEBUG(145, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'G':
- case 'g': goto yy231;
+ case 'g': goto yy233;
default: goto yy15;
}
-yy144:
- YYDEBUG(144, YYPEEK ());
+yy146:
+ YYDEBUG(146, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'D':
- case 'd': goto yy232;
+ case 'd': goto yy234;
default: goto yy15;
}
-yy145:
- YYDEBUG(145, YYPEEK ());
+yy147:
+ YYDEBUG(147, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'S':
- case 's': goto yy233;
+ case 's': goto yy235;
default: goto yy15;
}
-yy146:
- YYDEBUG(146, YYPEEK ());
+yy148:
+ YYDEBUG(148, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'N':
- case 'n': goto yy234;
+ case 'n': goto yy236;
default: goto yy15;
}
-yy147:
- YYDEBUG(147, YYPEEK ());
+yy149:
+ YYDEBUG(149, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'C':
- case 'c': goto yy235;
+ case 'c': goto yy237;
case 'L':
- case 'l': goto yy236;
+ case 'l': goto yy238;
default: goto yy15;
}
-yy148:
- YYDEBUG(148, YYPEEK ());
- yyaccept = 1;
+yy150:
+ YYDEBUG(150, YYPEEK ());
+ yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'G':
- case 'g': goto yy237;
+ case 'g': goto yy239;
default: goto yy15;
}
-yy149:
- YYDEBUG(149, YYPEEK ());
+yy151:
+ YYDEBUG(151, YYPEEK ());
yyaccept = 7;
YYSKIP ();
YYBACKUP ();
@@ -3923,96 +3937,96 @@ yy149:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy150;
+ default: goto yy152;
}
-yy150:
- YYDEBUG(150, YYPEEK ());
-#line 281 "../ada.re2c"
+yy152:
+ YYDEBUG(152, YYPEEK ());
+#line 288 "../ada.re2c"
{*id = 21; continue;}
-#line 3933 "../ada_re2c.c"
-yy151:
- YYDEBUG(151, YYPEEK ());
+#line 3947 "../ada_re2c.c"
+yy153:
+ YYDEBUG(153, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'S':
- case 's': goto yy238;
+ case 's': goto yy240;
default: goto yy15;
}
-yy152:
- YYDEBUG(152, YYPEEK ());
+yy154:
+ YYDEBUG(154, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'D':
- case 'd': goto yy239;
+ case 'd': goto yy241;
case 'T':
- case 't': goto yy241;
+ case 't': goto yy243;
default: goto yy15;
}
-yy153:
- YYDEBUG(153, YYPEEK ());
+yy155:
+ YYDEBUG(155, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'C':
- case 'c': goto yy242;
+ case 'c': goto yy244;
case 'I':
- case 'i': goto yy243;
+ case 'i': goto yy245;
default: goto yy15;
}
-yy154:
- YYDEBUG(154, YYPEEK ());
+yy156:
+ YYDEBUG(156, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'R':
- case 'r': goto yy244;
+ case 'r': goto yy246;
default: goto yy15;
}
-yy155:
- YYDEBUG(155, YYPEEK ());
+yy157:
+ YYDEBUG(157, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'N':
- case 'n': goto yy246;
+ case 'n': goto yy248;
default: goto yy15;
}
-yy156:
- YYDEBUG(156, YYPEEK ());
+yy158:
+ YYDEBUG(158, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'N':
- case 'n': goto yy247;
+ case 'n': goto yy249;
default: goto yy15;
}
-yy157:
- YYDEBUG(157, YYPEEK ());
+yy159:
+ YYDEBUG(159, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'T':
- case 't': goto yy248;
+ case 't': goto yy250;
default: goto yy15;
}
-yy158:
- YYDEBUG(158, YYPEEK ());
+yy160:
+ YYDEBUG(160, YYPEEK ());
yyaccept = 8;
YYSKIP ();
YYBACKUP ();
@@ -4133,15 +4147,15 @@ yy158:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy159;
+ default: goto yy161;
}
-yy159:
- YYDEBUG(159, YYPEEK ());
-#line 292 "../ada.re2c"
+yy161:
+ YYDEBUG(161, YYPEEK ());
+#line 299 "../ada.re2c"
{*id = 32; continue;}
-#line 4143 "../ada_re2c.c"
-yy160:
- YYDEBUG(160, YYPEEK ());
+#line 4157 "../ada_re2c.c"
+yy162:
+ YYDEBUG(162, YYPEEK ());
yyaccept = 9;
YYSKIP ();
YYBACKUP ();
@@ -4261,16 +4275,16 @@ yy160:
case 0xF3:
case 0xF4: goto yy15;
case 'T':
- case 't': goto yy249;
- default: goto yy161;
+ case 't': goto yy251;
+ default: goto yy163;
}
-yy161:
- YYDEBUG(161, YYPEEK ());
-#line 293 "../ada.re2c"
+yy163:
+ YYDEBUG(163, YYPEEK ());
+#line 300 "../ada.re2c"
{*id = 33; continue;}
-#line 4272 "../ada_re2c.c"
-yy162:
- YYDEBUG(162, YYPEEK ());
+#line 4286 "../ada_re2c.c"
+yy164:
+ YYDEBUG(164, YYPEEK ());
yyaccept = 10;
YYSKIP ();
YYBACKUP ();
@@ -4391,81 +4405,81 @@ yy162:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy163;
+ default: goto yy165;
}
-yy163:
- YYDEBUG(163, YYPEEK ());
-#line 295 "../ada.re2c"
+yy165:
+ YYDEBUG(165, YYPEEK ());
+#line 302 "../ada.re2c"
{*id = 35; continue;}
-#line 4401 "../ada_re2c.c"
-yy164:
- YYDEBUG(164, YYPEEK ());
+#line 4415 "../ada_re2c.c"
+yy166:
+ YYDEBUG(166, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'M':
- case 'm': goto yy250;
+ case 'm': goto yy252;
default: goto yy15;
}
-yy165:
- YYDEBUG(165, YYPEEK ());
+yy167:
+ YYDEBUG(167, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'O':
- case 'o': goto yy251;
+ case 'o': goto yy253;
default: goto yy15;
}
-yy166:
- YYDEBUG(166, YYPEEK ());
+yy168:
+ YYDEBUG(168, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'D':
- case 'd': goto yy252;
+ case 'd': goto yy254;
default: goto yy15;
}
-yy167:
- YYDEBUG(167, YYPEEK ());
+yy169:
+ YYDEBUG(169, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'W':
- case 'w': goto yy254;
+ case 'w': goto yy256;
default: goto yy15;
}
-yy168:
- YYDEBUG(168, YYPEEK ());
+yy170:
+ YYDEBUG(170, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'T':
- case 't': goto yy256;
+ case 't': goto yy258;
default: goto yy15;
}
-yy169:
- YYDEBUG(169, YYPEEK ());
+yy171:
+ YYDEBUG(171, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'L':
- case 'l': goto yy258;
+ case 'l': goto yy260;
default: goto yy15;
}
-yy170:
- YYDEBUG(170, YYPEEK ());
+yy172:
+ YYDEBUG(172, YYPEEK ());
yyaccept = 11;
YYSKIP ();
YYBACKUP ();
@@ -4586,15 +4600,15 @@ yy170:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy171;
+ default: goto yy173;
}
-yy171:
- YYDEBUG(171, YYPEEK ());
-#line 302 "../ada.re2c"
+yy173:
+ YYDEBUG(173, YYPEEK ());
+#line 309 "../ada.re2c"
{*id = 42; continue;}
-#line 4596 "../ada_re2c.c"
-yy172:
- YYDEBUG(172, YYPEEK ());
+#line 4610 "../ada_re2c.c"
+yy174:
+ YYDEBUG(174, YYPEEK ());
yyaccept = 12;
YYSKIP ();
YYBACKUP ();
@@ -4715,257 +4729,257 @@ yy172:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy173;
+ default: goto yy175;
}
-yy173:
- YYDEBUG(173, YYPEEK ());
-#line 303 "../ada.re2c"
+yy175:
+ YYDEBUG(175, YYPEEK ());
+#line 310 "../ada.re2c"
{*id = 43; continue;}
-#line 4725 "../ada_re2c.c"
-yy174:
- YYDEBUG(174, YYPEEK ());
+#line 4739 "../ada_re2c.c"
+yy176:
+ YYDEBUG(176, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'H':
- case 'h': goto yy259;
+ case 'h': goto yy261;
default: goto yy15;
}
-yy175:
- YYDEBUG(175, YYPEEK ());
+yy177:
+ YYDEBUG(177, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'T':
- case 't': goto yy260;
+ case 't': goto yy262;
default: goto yy15;
}
-yy176:
- YYDEBUG(176, YYPEEK ());
+yy178:
+ YYDEBUG(178, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy262;
+ case 'e': goto yy264;
default: goto yy15;
}
-yy177:
- YYDEBUG(177, YYPEEK ());
+yy179:
+ YYDEBUG(179, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'C':
- case 'c': goto yy263;
+ case 'c': goto yy265;
default: goto yy15;
}
-yy178:
- YYDEBUG(178, YYPEEK ());
+yy180:
+ YYDEBUG(180, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'A':
- case 'a': goto yy264;
+ case 'a': goto yy266;
case 'I':
- case 'i': goto yy265;
+ case 'i': goto yy267;
case 'O':
- case 'o': goto yy266;
+ case 'o': goto yy268;
default: goto yy15;
}
-yy179:
- YYDEBUG(179, YYPEEK ());
+yy181:
+ YYDEBUG(181, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'I':
- case 'i': goto yy267;
+ case 'i': goto yy269;
case 'N':
- case 'n': goto yy268;
+ case 'n': goto yy270;
default: goto yy15;
}
-yy180:
- YYDEBUG(180, YYPEEK ());
+yy182:
+ YYDEBUG(182, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'C':
- case 'c': goto yy269;
+ case 'c': goto yy271;
case 'M':
- case 'm': goto yy270;
+ case 'm': goto yy272;
case 'N':
- case 'n': goto yy272;
+ case 'n': goto yy274;
case 'Q':
- case 'q': goto yy273;
+ case 'q': goto yy275;
case 'T':
- case 't': goto yy274;
+ case 't': goto yy276;
case 'V':
- case 'v': goto yy275;
+ case 'v': goto yy277;
default: goto yy15;
}
-yy181:
- YYDEBUG(181, YYPEEK ());
+yy183:
+ YYDEBUG(183, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'L':
- case 'l': goto yy276;
+ case 'l': goto yy278;
case 'P':
- case 'p': goto yy277;
+ case 'p': goto yy279;
default: goto yy15;
}
-yy182:
- YYDEBUG(182, YYPEEK ());
+yy184:
+ YYDEBUG(184, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'M':
- case 'm': goto yy278;
+ case 'm': goto yy280;
default: goto yy15;
}
-yy183:
- YYDEBUG(183, YYPEEK ());
+yy185:
+ YYDEBUG(185, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'B':
- case 'b': goto yy279;
+ case 'b': goto yy281;
default: goto yy15;
}
-yy184:
- YYDEBUG(184, YYPEEK ());
+yy186:
+ YYDEBUG(186, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'N':
- case 'n': goto yy280;
+ case 'n': goto yy282;
default: goto yy15;
}
-yy185:
- YYDEBUG(185, YYPEEK ());
+yy187:
+ YYDEBUG(187, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'G':
- case 'g': goto yy281;
+ case 'g': goto yy283;
case 'S':
- case 's': goto yy282;
+ case 's': goto yy284;
default: goto yy15;
}
-yy186:
- YYDEBUG(186, YYPEEK ());
+yy188:
+ YYDEBUG(188, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'R':
- case 'r': goto yy283;
+ case 'r': goto yy285;
default: goto yy15;
}
-yy187:
- YYDEBUG(187, YYPEEK ());
+yy189:
+ YYDEBUG(189, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy284;
+ case 'e': goto yy286;
default: goto yy15;
}
-yy188:
- YYDEBUG(188, YYPEEK ());
+yy190:
+ YYDEBUG(190, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'P':
- case 'p': goto yy285;
+ case 'p': goto yy287;
default: goto yy15;
}
-yy189:
- YYDEBUG(189, YYPEEK ());
+yy191:
+ YYDEBUG(191, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'T':
- case 't': goto yy286;
+ case 't': goto yy288;
default: goto yy15;
}
-yy190:
- YYDEBUG(190, YYPEEK ());
+yy192:
+ YYDEBUG(192, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy287;
+ case 'e': goto yy289;
default: goto yy15;
}
-yy191:
- YYDEBUG(191, YYPEEK ());
+yy193:
+ YYDEBUG(193, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy289;
+ case 'e': goto yy291;
case 'I':
- case 'i': goto yy290;
+ case 'i': goto yy292;
default: goto yy15;
}
-yy192:
- YYDEBUG(192, YYPEEK ());
+yy194:
+ YYDEBUG(194, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'T':
- case 't': goto yy291;
+ case 't': goto yy293;
default: goto yy15;
}
-yy193:
- YYDEBUG(193, YYPEEK ());
+yy195:
+ YYDEBUG(195, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'R':
- case 'r': goto yy292;
+ case 'r': goto yy294;
default: goto yy15;
}
-yy194:
- YYDEBUG(194, YYPEEK ());
+yy196:
+ YYDEBUG(196, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -4990,15 +5004,15 @@ yy194:
case 'c':
case 'd':
case 'e':
- case 'f': goto yy294;
- default: goto yy81;
+ case 'f': goto yy296;
+ default: goto yy83;
}
-yy195:
- YYDEBUG(195, YYPEEK ());
+yy197:
+ YYDEBUG(197, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
-yy196:
- YYDEBUG(196, YYPEEK ());
+yy198:
+ YYDEBUG(198, YYPEEK ());
switch (yych) {
case 0x00:
case 0x01:
@@ -5124,10 +5138,10 @@ yy196:
case '{':
case '|':
case '~':
- case 0x7F: goto yy195;
+ case 0x7F: goto yy197;
case 0x04:
case '\n':
- case '}': goto yy197;
+ case '}': goto yy199;
case 0xC2:
case 0xC3:
case 0xC4:
@@ -5157,8 +5171,8 @@ yy196:
case 0xDC:
case 0xDD:
case 0xDE:
- case 0xDF: goto yy198;
- case 0xE0: goto yy199;
+ case 0xDF: goto yy200;
+ case 0xE0: goto yy201;
case 0xE1:
case 0xE2:
case 0xE3:
@@ -5173,20 +5187,20 @@ yy196:
case 0xEC:
case 0xED:
case 0xEE:
- case 0xEF: goto yy200;
- case 0xF0: goto yy201;
+ case 0xEF: goto yy202;
+ case 0xF0: goto yy203;
case 0xF1:
case 0xF2:
- case 0xF3: goto yy202;
- case 0xF4: goto yy203;
- default: goto yy81;
+ case 0xF3: goto yy204;
+ case 0xF4: goto yy205;
+ default: goto yy83;
}
-yy197:
- YYDEBUG(197, YYPEEK ());
+yy199:
+ YYDEBUG(199, YYPEEK ());
YYSKIP ();
- goto yy114;
-yy198:
- YYDEBUG(198, YYPEEK ());
+ goto yy116;
+yy200:
+ YYDEBUG(200, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -5253,11 +5267,11 @@ yy198:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy195;
- default: goto yy81;
+ case 0xBF: goto yy197;
+ default: goto yy83;
}
-yy199:
- YYDEBUG(199, YYPEEK ());
+yy201:
+ YYDEBUG(201, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -5292,11 +5306,11 @@ yy199:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy198;
- default: goto yy81;
+ case 0xBF: goto yy200;
+ default: goto yy83;
}
-yy200:
- YYDEBUG(200, YYPEEK ());
+yy202:
+ YYDEBUG(202, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -5363,11 +5377,11 @@ yy200:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy198;
- default: goto yy81;
+ case 0xBF: goto yy200;
+ default: goto yy83;
}
-yy201:
- YYDEBUG(201, YYPEEK ());
+yy203:
+ YYDEBUG(203, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -5418,11 +5432,11 @@ yy201:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy200;
- default: goto yy81;
+ case 0xBF: goto yy202;
+ default: goto yy83;
}
-yy202:
- YYDEBUG(202, YYPEEK ());
+yy204:
+ YYDEBUG(204, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -5489,12 +5503,12 @@ yy202:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy200;
- default: goto yy81;
+ case 0xBF: goto yy202;
+ default: goto yy83;
}
-yy203:
- YYDEBUG(203, YYPEEK ());
- YYSKIP ();
+yy205:
+ YYDEBUG(205, YYPEEK ());
+ YYSKIP ();
yych = YYPEEK ();
switch (yych) {
case 0x80:
@@ -5512,17 +5526,17 @@ yy203:
case 0x8C:
case 0x8D:
case 0x8E:
- case 0x8F: goto yy200;
- default: goto yy81;
+ case 0x8F: goto yy202;
+ default: goto yy83;
}
-yy204:
- YYDEBUG(204, YYPEEK ());
+yy206:
+ YYDEBUG(206, YYPEEK ());
yyaccept = 4;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
- case '"': goto yy79;
+ case '"': goto yy81;
case '0':
case '1':
case '2':
@@ -5544,35 +5558,35 @@ yy204:
case 'c':
case 'd':
case 'e':
- case 'f': goto yy296;
- default: goto yy83;
+ case 'f': goto yy298;
+ default: goto yy85;
}
-yy205:
- YYDEBUG(205, YYPEEK ());
+yy207:
+ YYDEBUG(207, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
- case 's': goto yy298;
- default: goto yy81;
+ case 's': goto yy300;
+ default: goto yy83;
}
-yy206:
- YYDEBUG(206, YYPEEK ());
+yy208:
+ YYDEBUG(208, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
- case 'd': goto yy112;
- default: goto yy81;
+ case 'd': goto yy114;
+ default: goto yy83;
}
-yy207:
- YYDEBUG(207, YYPEEK ());
- YYSKIP ();
-yy208:
- YYDEBUG(208, YYPEEK ());
-#line 366 "../ada.re2c"
- {*id = 106; continue;}
-#line 5574 "../ada_re2c.c"
yy209:
YYDEBUG(209, YYPEEK ());
+ YYSKIP ();
+yy210:
+ YYDEBUG(210, YYPEEK ());
+#line 374 "../ada.re2c"
+ {*id = 107; continue;}
+#line 5588 "../ada_re2c.c"
+yy211:
+ YYDEBUG(211, YYPEEK ());
yyaccept = 13;
YYSKIP ();
YYBACKUP ();
@@ -5672,8 +5686,8 @@ yy209:
case '|':
case '}':
case '~':
- case 0x7F: goto yy299;
- case '[': goto yy300;
+ case 0x7F: goto yy301;
+ case '[': goto yy302;
case 0xC2:
case 0xC3:
case 0xC4:
@@ -5703,8 +5717,8 @@ yy209:
case 0xDC:
case 0xDD:
case 0xDE:
- case 0xDF: goto yy301;
- case 0xE0: goto yy302;
+ case 0xDF: goto yy303;
+ case 0xE0: goto yy304;
case 0xE1:
case 0xE2:
case 0xE3:
@@ -5719,24 +5733,24 @@ yy209:
case 0xEC:
case 0xED:
case 0xEE:
- case 0xEF: goto yy303;
- case 0xF0: goto yy304;
+ case 0xEF: goto yy305;
+ case 0xF0: goto yy306;
case 0xF1:
case 0xF2:
- case 0xF3: goto yy305;
- case 0xF4: goto yy306;
- default: goto yy208;
+ case 0xF3: goto yy307;
+ case 0xF4: goto yy308;
+ default: goto yy210;
}
-yy210:
- YYDEBUG(210, YYPEEK ());
+yy212:
+ YYDEBUG(212, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
- case '"': goto yy81;
- default: goto yy308;
+ case '"': goto yy83;
+ default: goto yy310;
}
-yy211:
- YYDEBUG(211, YYPEEK ());
+yy213:
+ YYDEBUG(213, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -5803,11 +5817,11 @@ yy211:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy112;
- default: goto yy81;
+ case 0xBF: goto yy114;
+ default: goto yy83;
}
-yy212:
- YYDEBUG(212, YYPEEK ());
+yy214:
+ YYDEBUG(214, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -5842,11 +5856,11 @@ yy212:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy211;
- default: goto yy81;
+ case 0xBF: goto yy213;
+ default: goto yy83;
}
-yy213:
- YYDEBUG(213, YYPEEK ());
+yy215:
+ YYDEBUG(215, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -5913,11 +5927,11 @@ yy213:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy211;
- default: goto yy81;
+ case 0xBF: goto yy213;
+ default: goto yy83;
}
-yy214:
- YYDEBUG(214, YYPEEK ());
+yy216:
+ YYDEBUG(216, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -5968,11 +5982,11 @@ yy214:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy213;
- default: goto yy81;
+ case 0xBF: goto yy215;
+ default: goto yy83;
}
-yy215:
- YYDEBUG(215, YYPEEK ());
+yy217:
+ YYDEBUG(217, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -6039,11 +6053,11 @@ yy215:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy213;
- default: goto yy81;
+ case 0xBF: goto yy215;
+ default: goto yy83;
}
-yy216:
- YYDEBUG(216, YYPEEK ());
+yy218:
+ YYDEBUG(218, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -6062,17 +6076,17 @@ yy216:
case 0x8C:
case 0x8D:
case 0x8E:
- case 0x8F: goto yy213;
- default: goto yy81;
+ case 0x8F: goto yy215;
+ default: goto yy83;
}
-yy217:
- YYDEBUG(217, YYPEEK ());
+yy219:
+ YYDEBUG(219, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
-yy218:
- YYDEBUG(218, YYPEEK ());
+yy220:
+ YYDEBUG(220, YYPEEK ());
switch (yych) {
- case '#': goto yy309;
+ case '#': goto yy311;
case '-':
case '.':
case '0':
@@ -6097,22 +6111,22 @@ yy218:
case 'c':
case 'd':
case 'e':
- case 'f': goto yy217;
- default: goto yy81;
+ case 'f': goto yy219;
+ default: goto yy83;
}
-yy219:
- YYDEBUG(219, YYPEEK ());
+yy221:
+ YYDEBUG(221, YYPEEK ());
yyaccept = 3;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
- YYDEBUG(220, YYPEEK ());
+ YYDEBUG(222, YYPEEK ());
switch (yych) {
case '-':
case '.':
case 'E':
case '_':
- case 'e': goto yy120;
+ case 'e': goto yy122;
case '0':
case '1':
case '2':
@@ -6122,22 +6136,22 @@ yy219:
case '6':
case '7':
case '8':
- case '9': goto yy219;
+ case '9': goto yy221;
default: goto yy39;
}
-yy221:
- YYDEBUG(221, YYPEEK ());
+yy223:
+ YYDEBUG(223, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'R':
- case 'r': goto yy310;
+ case 'r': goto yy312;
default: goto yy15;
}
-yy222:
- YYDEBUG(222, YYPEEK ());
+yy224:
+ YYDEBUG(224, YYPEEK ());
yyaccept = 14;
YYSKIP ();
YYBACKUP ();
@@ -6257,38 +6271,38 @@ yy222:
case 0xF3:
case 0xF4: goto yy15;
case 'T':
- case 't': goto yy311;
- default: goto yy223;
+ case 't': goto yy313;
+ default: goto yy225;
}
-yy223:
- YYDEBUG(223, YYPEEK ());
-#line 263 "../ada.re2c"
+yy225:
+ YYDEBUG(225, YYPEEK ());
+#line 270 "../ada.re2c"
{*id = 3; continue;}
-#line 6268 "../ada_re2c.c"
-yy224:
- YYDEBUG(224, YYPEEK ());
+#line 6282 "../ada_re2c.c"
+yy226:
+ YYDEBUG(226, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy312;
+ case 'e': goto yy314;
default: goto yy15;
}
-yy225:
- YYDEBUG(225, YYPEEK ());
+yy227:
+ YYDEBUG(227, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'A':
- case 'a': goto yy313;
+ case 'a': goto yy315;
default: goto yy15;
}
-yy226:
- YYDEBUG(226, YYPEEK ());
+yy228:
+ YYDEBUG(228, YYPEEK ());
yyaccept = 15;
YYSKIP ();
YYBACKUP ();
@@ -6409,15 +6423,15 @@ yy226:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy227;
+ default: goto yy229;
}
-yy227:
- YYDEBUG(227, YYPEEK ());
-#line 269 "../ada.re2c"
+yy229:
+ YYDEBUG(229, YYPEEK ());
+#line 276 "../ada.re2c"
{*id = 9; continue;}
-#line 6419 "../ada_re2c.c"
-yy228:
- YYDEBUG(228, YYPEEK ());
+#line 6433 "../ada_re2c.c"
+yy230:
+ YYDEBUG(230, YYPEEK ());
yyaccept = 16;
YYSKIP ();
YYBACKUP ();
@@ -6538,118 +6552,118 @@ yy228:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy229;
+ default: goto yy231;
}
-yy229:
- YYDEBUG(229, YYPEEK ());
-#line 270 "../ada.re2c"
+yy231:
+ YYDEBUG(231, YYPEEK ());
+#line 277 "../ada.re2c"
{*id = 10; continue;}
-#line 6548 "../ada_re2c.c"
-yy230:
- YYDEBUG(230, YYPEEK ());
+#line 6562 "../ada_re2c.c"
+yy232:
+ YYDEBUG(232, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'A':
- case 'a': goto yy314;
+ case 'a': goto yy316;
default: goto yy15;
}
-yy231:
- YYDEBUG(231, YYPEEK ());
+yy233:
+ YYDEBUG(233, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'I':
- case 'i': goto yy315;
+ case 'i': goto yy317;
default: goto yy15;
}
-yy232:
- YYDEBUG(232, YYPEEK ());
+yy234:
+ YYDEBUG(234, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'Y':
- case 'y': goto yy316;
+ case 'y': goto yy318;
default: goto yy15;
}
-yy233:
- YYDEBUG(233, YYPEEK ());
+yy235:
+ YYDEBUG(235, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy318;
+ case 'e': goto yy320;
default: goto yy15;
}
-yy234:
- YYDEBUG(234, YYPEEK ());
+yy236:
+ YYDEBUG(236, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'S':
- case 's': goto yy320;
+ case 's': goto yy322;
default: goto yy15;
}
-yy235:
- YYDEBUG(235, YYPEEK ());
+yy237:
+ YYDEBUG(237, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'L':
- case 'l': goto yy321;
+ case 'l': goto yy323;
default: goto yy15;
}
-yy236:
- YYDEBUG(236, YYPEEK ());
+yy238:
+ YYDEBUG(238, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'A':
- case 'a': goto yy322;
+ case 'a': goto yy324;
case 'T':
- case 't': goto yy323;
+ case 't': goto yy325;
default: goto yy15;
}
-yy237:
- YYDEBUG(237, YYPEEK ());
+yy239:
+ YYDEBUG(239, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'I':
- case 'i': goto yy324;
+ case 'i': goto yy326;
default: goto yy15;
}
-yy238:
- YYDEBUG(238, YYPEEK ());
+yy240:
+ YYDEBUG(240, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy325;
+ case 'e': goto yy327;
case 'I':
- case 'i': goto yy327;
+ case 'i': goto yy329;
default: goto yy15;
}
-yy239:
- YYDEBUG(239, YYPEEK ());
+yy241:
+ YYDEBUG(241, YYPEEK ());
yyaccept = 17;
YYSKIP ();
YYBACKUP ();
@@ -6770,48 +6784,48 @@ yy239:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy240;
+ default: goto yy242;
}
-yy240:
- YYDEBUG(240, YYPEEK ());
-#line 284 "../ada.re2c"
+yy242:
+ YYDEBUG(242, YYPEEK ());
+#line 291 "../ada.re2c"
{*id = 24; continue;}
-#line 6780 "../ada_re2c.c"
-yy241:
- YYDEBUG(241, YYPEEK ());
+#line 6794 "../ada_re2c.c"
+yy243:
+ YYDEBUG(243, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'R':
- case 'r': goto yy328;
+ case 'r': goto yy330;
default: goto yy15;
}
-yy242:
- YYDEBUG(242, YYPEEK ());
+yy244:
+ YYDEBUG(244, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy329;
+ case 'e': goto yy331;
default: goto yy15;
}
-yy243:
- YYDEBUG(243, YYPEEK ());
+yy245:
+ YYDEBUG(245, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'T':
- case 't': goto yy330;
+ case 't': goto yy332;
default: goto yy15;
}
-yy244:
- YYDEBUG(244, YYPEEK ());
+yy246:
+ YYDEBUG(246, YYPEEK ());
yyaccept = 18;
YYSKIP ();
YYBACKUP ();
@@ -6932,81 +6946,81 @@ yy244:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy245;
+ default: goto yy247;
}
-yy245:
- YYDEBUG(245, YYPEEK ());
-#line 288 "../ada.re2c"
+yy247:
+ YYDEBUG(247, YYPEEK ());
+#line 295 "../ada.re2c"
{*id = 28; continue;}
-#line 6942 "../ada_re2c.c"
-yy246:
- YYDEBUG(246, YYPEEK ());
+#line 6956 "../ada_re2c.c"
+yy248:
+ YYDEBUG(248, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'C':
- case 'c': goto yy332;
+ case 'c': goto yy334;
default: goto yy15;
}
-yy247:
- YYDEBUG(247, YYPEEK ());
+yy249:
+ YYDEBUG(249, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy333;
+ case 'e': goto yy335;
default: goto yy15;
}
-yy248:
- YYDEBUG(248, YYPEEK ());
+yy250:
+ YYDEBUG(250, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'O':
- case 'o': goto yy334;
+ case 'o': goto yy336;
default: goto yy15;
}
-yy249:
- YYDEBUG(249, YYPEEK ());
+yy251:
+ YYDEBUG(251, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy336;
+ case 'e': goto yy338;
default: goto yy15;
}
-yy250:
- YYDEBUG(250, YYPEEK ());
+yy252:
+ YYDEBUG(252, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'I':
- case 'i': goto yy337;
+ case 'i': goto yy339;
default: goto yy15;
}
-yy251:
- YYDEBUG(251, YYPEEK ());
+yy253:
+ YYDEBUG(253, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'P':
- case 'p': goto yy338;
+ case 'p': goto yy340;
default: goto yy15;
}
-yy252:
- YYDEBUG(252, YYPEEK ());
+yy254:
+ YYDEBUG(254, YYPEEK ());
yyaccept = 19;
YYSKIP ();
YYBACKUP ();
@@ -7127,15 +7141,15 @@ yy252:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy253;
+ default: goto yy255;
}
-yy253:
- YYDEBUG(253, YYPEEK ());
-#line 298 "../ada.re2c"
+yy255:
+ YYDEBUG(255, YYPEEK ());
+#line 305 "../ada.re2c"
{*id = 38; continue;}
-#line 7137 "../ada_re2c.c"
-yy254:
- YYDEBUG(254, YYPEEK ());
+#line 7151 "../ada_re2c.c"
+yy256:
+ YYDEBUG(256, YYPEEK ());
yyaccept = 20;
YYSKIP ();
YYBACKUP ();
@@ -7256,15 +7270,15 @@ yy254:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy255;
+ default: goto yy257;
}
-yy255:
- YYDEBUG(255, YYPEEK ());
-#line 299 "../ada.re2c"
+yy257:
+ YYDEBUG(257, YYPEEK ());
+#line 306 "../ada.re2c"
{*id = 39; continue;}
-#line 7266 "../ada_re2c.c"
-yy256:
- YYDEBUG(256, YYPEEK ());
+#line 7280 "../ada_re2c.c"
+yy258:
+ YYDEBUG(258, YYPEEK ());
yyaccept = 21;
YYSKIP ();
YYBACKUP ();
@@ -7385,37 +7399,37 @@ yy256:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy257;
+ default: goto yy259;
}
-yy257:
- YYDEBUG(257, YYPEEK ());
-#line 300 "../ada.re2c"
+yy259:
+ YYDEBUG(259, YYPEEK ());
+#line 307 "../ada.re2c"
{*id = 40; continue;}
-#line 7395 "../ada_re2c.c"
-yy258:
- YYDEBUG(258, YYPEEK ());
+#line 7409 "../ada_re2c.c"
+yy260:
+ YYDEBUG(260, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'L':
- case 'l': goto yy340;
+ case 'l': goto yy342;
default: goto yy15;
}
-yy259:
- YYDEBUG(259, YYPEEK ());
+yy261:
+ YYDEBUG(261, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy342;
+ case 'e': goto yy344;
default: goto yy15;
}
-yy260:
- YYDEBUG(260, YYPEEK ());
+yy262:
+ YYDEBUG(262, YYPEEK ());
yyaccept = 22;
YYSKIP ();
YYBACKUP ();
@@ -7536,105 +7550,105 @@ yy260:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy261;
+ default: goto yy263;
}
-yy261:
- YYDEBUG(261, YYPEEK ());
-#line 305 "../ada.re2c"
+yy263:
+ YYDEBUG(263, YYPEEK ());
+#line 312 "../ada.re2c"
{*id = 45; continue;}
-#line 7546 "../ada_re2c.c"
-yy262:
- YYDEBUG(262, YYPEEK ());
+#line 7560 "../ada_re2c.c"
+yy264:
+ YYDEBUG(264, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'R':
- case 'r': goto yy343;
+ case 'r': goto yy345;
default: goto yy15;
}
-yy263:
- YYDEBUG(263, YYPEEK ());
+yy265:
+ YYDEBUG(265, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'K':
- case 'k': goto yy344;
+ case 'k': goto yy346;
default: goto yy15;
}
-yy264:
- YYDEBUG(264, YYPEEK ());
+yy266:
+ YYDEBUG(266, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'G':
- case 'g': goto yy345;
+ case 'g': goto yy347;
default: goto yy15;
}
-yy265:
- YYDEBUG(265, YYPEEK ());
+yy267:
+ YYDEBUG(267, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'V':
- case 'v': goto yy346;
+ case 'v': goto yy348;
default: goto yy15;
}
-yy266:
- YYDEBUG(266, YYPEEK ());
+yy268:
+ YYDEBUG(268, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'C':
- case 'c': goto yy347;
+ case 'c': goto yy349;
case 'T':
- case 't': goto yy348;
+ case 't': goto yy350;
default: goto yy15;
}
-yy267:
- YYDEBUG(267, YYPEEK ());
+yy269:
+ YYDEBUG(269, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'S':
- case 's': goto yy349;
+ case 's': goto yy351;
default: goto yy15;
}
-yy268:
- YYDEBUG(268, YYPEEK ());
+yy270:
+ YYDEBUG(270, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'G':
- case 'g': goto yy350;
+ case 'g': goto yy352;
default: goto yy15;
}
-yy269:
- YYDEBUG(269, YYPEEK ());
+yy271:
+ YYDEBUG(271, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'O':
- case 'o': goto yy351;
+ case 'o': goto yy353;
default: goto yy15;
}
-yy270:
- YYDEBUG(270, YYPEEK ());
+yy272:
+ YYDEBUG(272, YYPEEK ());
yyaccept = 23;
YYSKIP ();
YYBACKUP ();
@@ -7755,35 +7769,13 @@ yy270:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy271;
- }
-yy271:
- YYDEBUG(271, YYPEEK ());
-#line 315 "../ada.re2c"
- {*id = 55; continue;}
-#line 7765 "../ada_re2c.c"
-yy272:
- YYDEBUG(272, YYPEEK ());
- yyaccept = 1;
- YYSKIP ();
- YYBACKUP ();
- yych = YYPEEK ();
- switch (yych) {
- case 'A':
- case 'a': goto yy352;
- default: goto yy15;
+ default: goto yy273;
}
yy273:
YYDEBUG(273, YYPEEK ());
- yyaccept = 1;
- YYSKIP ();
- YYBACKUP ();
- yych = YYPEEK ();
- switch (yych) {
- case 'U':
- case 'u': goto yy353;
- default: goto yy15;
- }
+#line 322 "../ada.re2c"
+ {*id = 55; continue;}
+#line 7779 "../ada_re2c.c"
yy274:
YYDEBUG(274, YYPEEK ());
yyaccept = 1;
@@ -7791,8 +7783,8 @@ yy274:
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
- case 'U':
- case 'u': goto yy354;
+ case 'A':
+ case 'a': goto yy354;
default: goto yy15;
}
yy275:
@@ -7802,8 +7794,8 @@ yy275:
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
- case 'E':
- case 'e': goto yy355;
+ case 'U':
+ case 'u': goto yy355;
default: goto yy15;
}
yy276:
@@ -7813,8 +7805,8 @@ yy276:
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
- case 'E':
- case 'e': goto yy356;
+ case 'U':
+ case 'u': goto yy356;
default: goto yy15;
}
yy277:
@@ -7824,8 +7816,8 @@ yy277:
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
- case 'A':
- case 'a': goto yy357;
+ case 'E':
+ case 'e': goto yy357;
default: goto yy15;
}
yy278:
@@ -7846,8 +7838,8 @@ yy279:
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
- case 'T':
- case 't': goto yy360;
+ case 'A':
+ case 'a': goto yy359;
default: goto yy15;
}
yy280:
@@ -7857,8 +7849,8 @@ yy280:
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
- case 'C':
- case 'c': goto yy361;
+ case 'E':
+ case 'e': goto yy360;
default: goto yy15;
}
yy281:
@@ -7868,8 +7860,8 @@ yy281:
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
- case 'G':
- case 'g': goto yy362;
+ case 'T':
+ case 't': goto yy362;
default: goto yy15;
}
yy282:
@@ -7879,8 +7871,8 @@ yy282:
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
- case 'K':
- case 'k': goto yy363;
+ case 'C':
+ case 'c': goto yy363;
default: goto yy15;
}
yy283:
@@ -7890,8 +7882,8 @@ yy283:
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
- case 'M':
- case 'm': goto yy365;
+ case 'G':
+ case 'g': goto yy364;
default: goto yy15;
}
yy284:
@@ -7901,8 +7893,8 @@ yy284:
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
- case 'N':
- case 'n': goto yy366;
+ case 'K':
+ case 'k': goto yy365;
default: goto yy15;
}
yy285:
@@ -7912,8 +7904,8 @@ yy285:
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
- case 'E':
- case 'e': goto yy368;
+ case 'M':
+ case 'm': goto yy367;
default: goto yy15;
}
yy286:
@@ -7923,12 +7915,34 @@ yy286:
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
- case 'I':
- case 'i': goto yy370;
+ case 'N':
+ case 'n': goto yy368;
default: goto yy15;
}
yy287:
YYDEBUG(287, YYPEEK ());
+ yyaccept = 1;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'E':
+ case 'e': goto yy370;
+ default: goto yy15;
+ }
+yy288:
+ YYDEBUG(288, YYPEEK ());
+ yyaccept = 1;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'I':
+ case 'i': goto yy372;
+ default: goto yy15;
+ }
+yy289:
+ YYDEBUG(289, YYPEEK ());
yyaccept = 24;
YYSKIP ();
YYBACKUP ();
@@ -8049,48 +8063,48 @@ yy287:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy288;
+ default: goto yy290;
}
-yy288:
- YYDEBUG(288, YYPEEK ());
-#line 331 "../ada.re2c"
+yy290:
+ YYDEBUG(290, YYPEEK ());
+#line 338 "../ada.re2c"
{*id = 71; continue;}
-#line 8059 "../ada_re2c.c"
-yy289:
- YYDEBUG(289, YYPEEK ());
+#line 8073 "../ada_re2c.c"
+yy291:
+ YYDEBUG(291, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'N':
- case 'n': goto yy371;
+ case 'n': goto yy373;
default: goto yy15;
}
-yy290:
- YYDEBUG(290, YYPEEK ());
+yy292:
+ YYDEBUG(292, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'L':
- case 'l': goto yy373;
+ case 'l': goto yy375;
default: goto yy15;
}
-yy291:
- YYDEBUG(291, YYPEEK ());
+yy293:
+ YYDEBUG(293, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'H':
- case 'h': goto yy374;
+ case 'h': goto yy376;
default: goto yy15;
}
-yy292:
- YYDEBUG(292, YYPEEK ());
+yy294:
+ YYDEBUG(294, YYPEEK ());
yyaccept = 25;
YYSKIP ();
YYBACKUP ();
@@ -8211,20 +8225,20 @@ yy292:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy293;
+ default: goto yy295;
}
-yy293:
- YYDEBUG(293, YYPEEK ());
-#line 335 "../ada.re2c"
+yy295:
+ YYDEBUG(295, YYPEEK ());
+#line 342 "../ada.re2c"
{*id = 75; continue;}
-#line 8221 "../ada_re2c.c"
-yy294:
- YYDEBUG(294, YYPEEK ());
+#line 8235 "../ada_re2c.c"
+yy296:
+ YYDEBUG(296, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
- YYDEBUG(295, YYPEEK ());
+ YYDEBUG(297, YYPEEK ());
switch (yych) {
- case '"': goto yy376;
+ case '"': goto yy378;
case '0':
case '1':
case '2':
@@ -8246,16 +8260,16 @@ yy294:
case 'c':
case 'd':
case 'e':
- case 'f': goto yy294;
- default: goto yy81;
+ case 'f': goto yy296;
+ default: goto yy83;
}
-yy296:
- YYDEBUG(296, YYPEEK ());
+yy298:
+ YYDEBUG(298, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
- YYDEBUG(297, YYPEEK ());
+ YYDEBUG(299, YYPEEK ());
switch (yych) {
- case '"': goto yy377;
+ case '"': goto yy379;
case '0':
case '1':
case '2':
@@ -8277,37 +8291,37 @@ yy296:
case 'c':
case 'd':
case 'e':
- case 'f': goto yy296;
- default: goto yy81;
+ case 'f': goto yy298;
+ default: goto yy83;
}
-yy298:
- YYDEBUG(298, YYPEEK ());
+yy300:
+ YYDEBUG(300, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
- case 'e': goto yy112;
- case 'i': goto yy93;
- default: goto yy81;
+ case 'e': goto yy114;
+ case 'i': goto yy95;
+ default: goto yy83;
}
-yy299:
- YYDEBUG(299, YYPEEK ());
+yy301:
+ YYDEBUG(301, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
- case '\'': goto yy378;
- default: goto yy81;
+ case '\'': goto yy380;
+ default: goto yy83;
}
-yy300:
- YYDEBUG(300, YYPEEK ());
+yy302:
+ YYDEBUG(302, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
- case '"': goto yy380;
- case '\'': goto yy378;
- default: goto yy81;
+ case '"': goto yy382;
+ case '\'': goto yy380;
+ default: goto yy83;
}
-yy301:
- YYDEBUG(301, YYPEEK ());
+yy303:
+ YYDEBUG(303, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -8374,11 +8388,11 @@ yy301:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy299;
- default: goto yy81;
+ case 0xBF: goto yy301;
+ default: goto yy83;
}
-yy302:
- YYDEBUG(302, YYPEEK ());
+yy304:
+ YYDEBUG(304, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -8413,11 +8427,11 @@ yy302:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy301;
- default: goto yy81;
+ case 0xBF: goto yy303;
+ default: goto yy83;
}
-yy303:
- YYDEBUG(303, YYPEEK ());
+yy305:
+ YYDEBUG(305, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -8484,11 +8498,11 @@ yy303:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy301;
- default: goto yy81;
+ case 0xBF: goto yy303;
+ default: goto yy83;
}
-yy304:
- YYDEBUG(304, YYPEEK ());
+yy306:
+ YYDEBUG(306, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -8539,11 +8553,11 @@ yy304:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy303;
- default: goto yy81;
+ case 0xBF: goto yy305;
+ default: goto yy83;
}
-yy305:
- YYDEBUG(305, YYPEEK ());
+yy307:
+ YYDEBUG(307, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -8610,11 +8624,11 @@ yy305:
case 0xBC:
case 0xBD:
case 0xBE:
- case 0xBF: goto yy303;
- default: goto yy81;
+ case 0xBF: goto yy305;
+ default: goto yy83;
}
-yy306:
- YYDEBUG(306, YYPEEK ());
+yy308:
+ YYDEBUG(308, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
@@ -8633,17 +8647,17 @@ yy306:
case 0x8C:
case 0x8D:
case 0x8E:
- case 0x8F: goto yy303;
- default: goto yy81;
+ case 0x8F: goto yy305;
+ default: goto yy83;
}
-yy307:
- YYDEBUG(307, YYPEEK ());
+yy309:
+ YYDEBUG(309, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
-yy308:
- YYDEBUG(308, YYPEEK ());
+yy310:
+ YYDEBUG(310, YYPEEK ());
switch (yych) {
- case '"': goto yy381;
+ case '"': goto yy383;
case '0':
case '1':
case '2':
@@ -8665,83 +8679,83 @@ yy308:
case 'c':
case 'd':
case 'e':
- case 'f': goto yy307;
- default: goto yy81;
+ case 'f': goto yy309;
+ default: goto yy83;
}
-yy309:
- YYDEBUG(309, YYPEEK ());
+yy311:
+ YYDEBUG(311, YYPEEK ());
YYSKIP ();
goto yy39;
-yy310:
- YYDEBUG(310, YYPEEK ());
+yy312:
+ YYDEBUG(312, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'T':
- case 't': goto yy382;
+ case 't': goto yy384;
default: goto yy15;
}
-yy311:
- YYDEBUG(311, YYPEEK ());
+yy313:
+ YYDEBUG(313, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'R':
- case 'r': goto yy384;
+ case 'r': goto yy386;
default: goto yy15;
}
-yy312:
- YYDEBUG(312, YYPEEK ());
+yy314:
+ YYDEBUG(314, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'P':
- case 'p': goto yy385;
+ case 'p': goto yy387;
case 'S':
- case 's': goto yy386;
+ case 's': goto yy388;
default: goto yy15;
}
-yy313:
- YYDEBUG(313, YYPEEK ());
+yy315:
+ YYDEBUG(315, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'S':
- case 's': goto yy387;
+ case 's': goto yy389;
default: goto yy15;
}
-yy314:
- YYDEBUG(314, YYPEEK ());
+yy316:
+ YYDEBUG(316, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'Y':
- case 'y': goto yy388;
+ case 'y': goto yy390;
default: goto yy15;
}
-yy315:
- YYDEBUG(315, YYPEEK ());
+yy317:
+ YYDEBUG(317, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'N':
- case 'n': goto yy390;
+ case 'n': goto yy392;
default: goto yy15;
}
-yy316:
- YYDEBUG(316, YYPEEK ());
+yy318:
+ YYDEBUG(318, YYPEEK ());
yyaccept = 26;
YYSKIP ();
YYBACKUP ();
@@ -8862,15 +8876,15 @@ yy316:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy317;
+ default: goto yy319;
}
-yy317:
- YYDEBUG(317, YYPEEK ());
-#line 274 "../ada.re2c"
+yy319:
+ YYDEBUG(319, YYPEEK ());
+#line 281 "../ada.re2c"
{*id = 14; continue;}
-#line 8872 "../ada_re2c.c"
-yy318:
- YYDEBUG(318, YYPEEK ());
+#line 8886 "../ada_re2c.c"
+yy320:
+ YYDEBUG(320, YYPEEK ());
yyaccept = 27;
YYSKIP ();
YYBACKUP ();
@@ -8991,70 +9005,70 @@ yy318:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy319;
+ default: goto yy321;
}
-yy319:
- YYDEBUG(319, YYPEEK ());
-#line 275 "../ada.re2c"
+yy321:
+ YYDEBUG(321, YYPEEK ());
+#line 282 "../ada.re2c"
{*id = 15; continue;}
-#line 9001 "../ada_re2c.c"
-yy320:
- YYDEBUG(320, YYPEEK ());
+#line 9015 "../ada_re2c.c"
+yy322:
+ YYDEBUG(322, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'T':
- case 't': goto yy392;
+ case 't': goto yy394;
default: goto yy15;
}
-yy321:
- YYDEBUG(321, YYPEEK ());
+yy323:
+ YYDEBUG(323, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'A':
- case 'a': goto yy393;
+ case 'a': goto yy395;
default: goto yy15;
}
-yy322:
- YYDEBUG(322, YYPEEK ());
+yy324:
+ YYDEBUG(324, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'Y':
- case 'y': goto yy394;
+ case 'y': goto yy396;
default: goto yy15;
}
-yy323:
- YYDEBUG(323, YYPEEK ());
+yy325:
+ YYDEBUG(325, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'A':
- case 'a': goto yy396;
+ case 'a': goto yy398;
default: goto yy15;
}
-yy324:
- YYDEBUG(324, YYPEEK ());
+yy326:
+ YYDEBUG(326, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'T':
- case 't': goto yy398;
+ case 't': goto yy400;
default: goto yy15;
}
-yy325:
- YYDEBUG(325, YYPEEK ());
+yy327:
+ YYDEBUG(327, YYPEEK ());
yyaccept = 28;
YYSKIP ();
YYBACKUP ();
@@ -9175,48 +9189,48 @@ yy325:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy326;
+ default: goto yy328;
}
-yy326:
- YYDEBUG(326, YYPEEK ());
-#line 282 "../ada.re2c"
+yy328:
+ YYDEBUG(328, YYPEEK ());
+#line 289 "../ada.re2c"
{*id = 22; continue;}
-#line 9185 "../ada_re2c.c"
-yy327:
- YYDEBUG(327, YYPEEK ());
+#line 9199 "../ada_re2c.c"
+yy329:
+ YYDEBUG(329, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'F':
- case 'f': goto yy399;
+ case 'f': goto yy401;
default: goto yy15;
}
-yy328:
- YYDEBUG(328, YYPEEK ());
+yy330:
+ YYDEBUG(330, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'Y':
- case 'y': goto yy401;
+ case 'y': goto yy403;
default: goto yy15;
}
-yy329:
- YYDEBUG(329, YYPEEK ());
+yy331:
+ YYDEBUG(331, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'P':
- case 'p': goto yy403;
+ case 'p': goto yy405;
default: goto yy15;
}
-yy330:
- YYDEBUG(330, YYPEEK ());
+yy332:
+ YYDEBUG(332, YYPEEK ());
yyaccept = 29;
YYSKIP ();
YYBACKUP ();
@@ -9337,37 +9351,37 @@ yy330:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy331;
+ default: goto yy333;
}
-yy331:
- YYDEBUG(331, YYPEEK ());
-#line 287 "../ada.re2c"
+yy333:
+ YYDEBUG(333, YYPEEK ());
+#line 294 "../ada.re2c"
{*id = 27; continue;}
-#line 9347 "../ada_re2c.c"
-yy332:
- YYDEBUG(332, YYPEEK ());
+#line 9361 "../ada_re2c.c"
+yy334:
+ YYDEBUG(334, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'T':
- case 't': goto yy404;
+ case 't': goto yy406;
default: goto yy15;
}
-yy333:
- YYDEBUG(333, YYPEEK ());
+yy335:
+ YYDEBUG(335, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'R':
- case 'r': goto yy405;
+ case 'r': goto yy407;
default: goto yy15;
}
-yy334:
- YYDEBUG(334, YYPEEK ());
+yy336:
+ YYDEBUG(336, YYPEEK ());
yyaccept = 30;
YYSKIP ();
YYBACKUP ();
@@ -9488,37 +9502,37 @@ yy334:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy335;
+ default: goto yy337;
}
-yy335:
- YYDEBUG(335, YYPEEK ());
-#line 291 "../ada.re2c"
+yy337:
+ YYDEBUG(337, YYPEEK ());
+#line 298 "../ada.re2c"
{*id = 31; continue;}
-#line 9498 "../ada_re2c.c"
-yy336:
- YYDEBUG(336, YYPEEK ());
+#line 9512 "../ada_re2c.c"
+yy338:
+ YYDEBUG(338, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'R':
- case 'r': goto yy406;
+ case 'r': goto yy408;
default: goto yy15;
}
-yy337:
- YYDEBUG(337, YYPEEK ());
+yy339:
+ YYDEBUG(339, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'T':
- case 't': goto yy407;
+ case 't': goto yy409;
default: goto yy15;
}
-yy338:
- YYDEBUG(338, YYPEEK ());
+yy340:
+ YYDEBUG(340, YYPEEK ());
yyaccept = 31;
YYSKIP ();
YYBACKUP ();
@@ -9639,15 +9653,15 @@ yy338:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy339;
+ default: goto yy341;
}
-yy339:
- YYDEBUG(339, YYPEEK ());
-#line 297 "../ada.re2c"
+yy341:
+ YYDEBUG(341, YYPEEK ());
+#line 304 "../ada.re2c"
{*id = 37; continue;}
-#line 9649 "../ada_re2c.c"
-yy340:
- YYDEBUG(340, YYPEEK ());
+#line 9663 "../ada_re2c.c"
+yy342:
+ YYDEBUG(342, YYPEEK ());
yyaccept = 32;
YYSKIP ();
YYBACKUP ();
@@ -9768,35 +9782,13 @@ yy340:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy341;
- }
-yy341:
- YYDEBUG(341, YYPEEK ());
-#line 301 "../ada.re2c"
- {*id = 41; continue;}
-#line 9778 "../ada_re2c.c"
-yy342:
- YYDEBUG(342, YYPEEK ());
- yyaccept = 1;
- YYSKIP ();
- YYBACKUP ();
- yych = YYPEEK ();
- switch (yych) {
- case 'R':
- case 'r': goto yy408;
- default: goto yy15;
+ default: goto yy343;
}
yy343:
YYDEBUG(343, YYPEEK ());
- yyaccept = 1;
- YYSKIP ();
- YYBACKUP ();
- yych = YYPEEK ();
- switch (yych) {
- case 'R':
- case 'r': goto yy409;
- default: goto yy15;
- }
+#line 308 "../ada.re2c"
+ {*id = 41; continue;}
+#line 9792 "../ada_re2c.c"
yy344:
YYDEBUG(344, YYPEEK ());
yyaccept = 1;
@@ -9804,8 +9796,8 @@ yy344:
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
- case 'A':
- case 'a': goto yy410;
+ case 'R':
+ case 'r': goto yy410;
default: goto yy15;
}
yy345:
@@ -9815,8 +9807,8 @@ yy345:
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
- case 'M':
- case 'm': goto yy411;
+ case 'R':
+ case 'r': goto yy411;
default: goto yy15;
}
yy346:
@@ -9837,8 +9829,8 @@ yy347:
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
- case 'E':
- case 'e': goto yy413;
+ case 'M':
+ case 'm': goto yy413;
default: goto yy15;
}
yy348:
@@ -9848,8 +9840,8 @@ yy348:
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
- case 'E':
- case 'e': goto yy414;
+ case 'A':
+ case 'a': goto yy414;
default: goto yy15;
}
yy349:
@@ -9871,7 +9863,7 @@ yy350:
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy417;
+ case 'e': goto yy416;
default: goto yy15;
}
yy351:
@@ -9881,8 +9873,8 @@ yy351:
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
- case 'R':
- case 'r': goto yy419;
+ case 'E':
+ case 'e': goto yy417;
default: goto yy15;
}
yy352:
@@ -9892,8 +9884,8 @@ yy352:
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
- case 'M':
- case 'm': goto yy420;
+ case 'E':
+ case 'e': goto yy419;
default: goto yy15;
}
yy353:
@@ -9903,8 +9895,8 @@ yy353:
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
- case 'E':
- case 'e': goto yy421;
+ case 'R':
+ case 'r': goto yy421;
default: goto yy15;
}
yy354:
@@ -9914,8 +9906,8 @@ yy354:
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
- case 'R':
- case 'r': goto yy422;
+ case 'M':
+ case 'm': goto yy422;
default: goto yy15;
}
yy355:
@@ -9925,8 +9917,8 @@ yy355:
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
- case 'R':
- case 'r': goto yy423;
+ case 'E':
+ case 'e': goto yy423;
default: goto yy15;
}
yy356:
@@ -9936,8 +9928,8 @@ yy356:
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
- case 'C':
- case 'c': goto yy424;
+ case 'R':
+ case 'r': goto yy424;
default: goto yy15;
}
yy357:
@@ -9953,6 +9945,28 @@ yy357:
}
yy358:
YYDEBUG(358, YYPEEK ());
+ yyaccept = 1;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'C':
+ case 'c': goto yy426;
+ default: goto yy15;
+ }
+yy359:
+ YYDEBUG(359, YYPEEK ());
+ yyaccept = 1;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'R':
+ case 'r': goto yy427;
+ default: goto yy15;
+ }
+yy360:
+ YYDEBUG(360, YYPEEK ());
yyaccept = 33;
YYSKIP ();
YYBACKUP ();
@@ -10073,48 +10087,48 @@ yy358:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy359;
+ default: goto yy361;
}
-yy359:
- YYDEBUG(359, YYPEEK ());
-#line 322 "../ada.re2c"
+yy361:
+ YYDEBUG(361, YYPEEK ());
+#line 329 "../ada.re2c"
{*id = 62; continue;}
-#line 10083 "../ada_re2c.c"
-yy360:
- YYDEBUG(360, YYPEEK ());
+#line 10097 "../ada_re2c.c"
+yy362:
+ YYDEBUG(362, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'Y':
- case 'y': goto yy426;
+ case 'y': goto yy428;
default: goto yy15;
}
-yy361:
- YYDEBUG(361, YYPEEK ());
+yy363:
+ YYDEBUG(363, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'H':
- case 'h': goto yy427;
+ case 'h': goto yy429;
default: goto yy15;
}
-yy362:
- YYDEBUG(362, YYPEEK ());
+yy364:
+ YYDEBUG(364, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy428;
+ case 'e': goto yy430;
default: goto yy15;
}
-yy363:
- YYDEBUG(363, YYPEEK ());
+yy365:
+ YYDEBUG(365, YYPEEK ());
yyaccept = 34;
YYSKIP ();
YYBACKUP ();
@@ -10235,26 +10249,26 @@ yy363:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy364;
+ default: goto yy366;
}
-yy364:
- YYDEBUG(364, YYPEEK ());
-#line 326 "../ada.re2c"
+yy366:
+ YYDEBUG(366, YYPEEK ());
+#line 333 "../ada.re2c"
{*id = 66; continue;}
-#line 10245 "../ada_re2c.c"
-yy365:
- YYDEBUG(365, YYPEEK ());
+#line 10259 "../ada_re2c.c"
+yy367:
+ YYDEBUG(367, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'I':
- case 'i': goto yy429;
+ case 'i': goto yy431;
default: goto yy15;
}
-yy366:
- YYDEBUG(366, YYPEEK ());
+yy368:
+ YYDEBUG(368, YYPEEK ());
yyaccept = 35;
YYSKIP ();
YYBACKUP ();
@@ -10375,15 +10389,15 @@ yy366:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy367;
+ default: goto yy369;
}
-yy367:
- YYDEBUG(367, YYPEEK ());
-#line 328 "../ada.re2c"
+yy369:
+ YYDEBUG(369, YYPEEK ());
+#line 335 "../ada.re2c"
{*id = 68; continue;}
-#line 10385 "../ada_re2c.c"
-yy368:
- YYDEBUG(368, YYPEEK ());
+#line 10399 "../ada_re2c.c"
+yy370:
+ YYDEBUG(370, YYPEEK ());
yyaccept = 36;
YYSKIP ();
YYBACKUP ();
@@ -10504,26 +10518,26 @@ yy368:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy369;
+ default: goto yy371;
}
-yy369:
- YYDEBUG(369, YYPEEK ());
-#line 329 "../ada.re2c"
+yy371:
+ YYDEBUG(371, YYPEEK ());
+#line 336 "../ada.re2c"
{*id = 69; continue;}
-#line 10514 "../ada_re2c.c"
-yy370:
- YYDEBUG(370, YYPEEK ());
+#line 10528 "../ada_re2c.c"
+yy372:
+ YYDEBUG(372, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'L':
- case 'l': goto yy430;
+ case 'l': goto yy432;
default: goto yy15;
}
-yy371:
- YYDEBUG(371, YYPEEK ());
+yy373:
+ YYDEBUG(373, YYPEEK ());
yyaccept = 37;
YYSKIP ();
YYBACKUP ();
@@ -10644,26 +10658,26 @@ yy371:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy372;
+ default: goto yy374;
}
-yy372:
- YYDEBUG(372, YYPEEK ());
-#line 332 "../ada.re2c"
+yy374:
+ YYDEBUG(374, YYPEEK ());
+#line 339 "../ada.re2c"
{*id = 72; continue;}
-#line 10654 "../ada_re2c.c"
-yy373:
- YYDEBUG(373, YYPEEK ());
+#line 10668 "../ada_re2c.c"
+yy375:
+ YYDEBUG(375, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy432;
+ case 'e': goto yy434;
default: goto yy15;
}
-yy374:
- YYDEBUG(374, YYPEEK ());
+yy376:
+ YYDEBUG(376, YYPEEK ());
yyaccept = 38;
YYSKIP ();
YYBACKUP ();
@@ -10784,55 +10798,55 @@ yy374:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy375;
- }
-yy375:
- YYDEBUG(375, YYPEEK ());
-#line 334 "../ada.re2c"
- {*id = 74; continue;}
-#line 10794 "../ada_re2c.c"
-yy376:
- YYDEBUG(376, YYPEEK ());
- YYSKIP ();
- yych = YYPEEK ();
- switch (yych) {
- case ']': goto yy14;
- default: goto yy81;
+ default: goto yy377;
}
yy377:
YYDEBUG(377, YYPEEK ());
+#line 341 "../ada.re2c"
+ {*id = 74; continue;}
+#line 10808 "../ada_re2c.c"
+yy378:
+ YYDEBUG(378, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
- case ']': goto yy79;
- default: goto yy81;
+ case ']': goto yy14;
+ default: goto yy83;
}
-yy378:
- YYDEBUG(378, YYPEEK ());
- YYSKIP ();
+yy379:
YYDEBUG(379, YYPEEK ());
- YYRESTORECTX ();
-#line 362 "../ada.re2c"
- {*id = 102; continue;}
-#line 10818 "../ada_re2c.c"
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case ']': goto yy81;
+ default: goto yy83;
+ }
yy380:
YYDEBUG(380, YYPEEK ());
YYSKIP ();
+ YYDEBUG(381, YYPEEK ());
+ YYRESTORECTX ();
+#line 370 "../ada.re2c"
+ {*id = 103; continue;}
+#line 10832 "../ada_re2c.c"
+yy382:
+ YYDEBUG(382, YYPEEK ());
+ YYSKIP ();
yych = YYPEEK ();
switch (yych) {
- case '"': goto yy81;
- default: goto yy435;
+ case '"': goto yy83;
+ default: goto yy437;
}
-yy381:
- YYDEBUG(381, YYPEEK ());
+yy383:
+ YYDEBUG(383, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
- case ']': goto yy101;
- default: goto yy81;
+ case ']': goto yy103;
+ default: goto yy83;
}
-yy382:
- YYDEBUG(382, YYPEEK ());
+yy384:
+ YYDEBUG(384, YYPEEK ());
yyaccept = 39;
YYSKIP ();
YYBACKUP ();
@@ -10953,59 +10967,59 @@ yy382:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy383;
+ default: goto yy385;
}
-yy383:
- YYDEBUG(383, YYPEEK ());
-#line 265 "../ada.re2c"
+yy385:
+ YYDEBUG(385, YYPEEK ());
+#line 272 "../ada.re2c"
{*id = 5; continue;}
-#line 10963 "../ada_re2c.c"
-yy384:
- YYDEBUG(384, YYPEEK ());
+#line 10977 "../ada_re2c.c"
+yy386:
+ YYDEBUG(386, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'A':
- case 'a': goto yy436;
+ case 'a': goto yy438;
default: goto yy15;
}
-yy385:
- YYDEBUG(385, YYPEEK ());
+yy387:
+ YYDEBUG(387, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'T':
- case 't': goto yy437;
+ case 't': goto yy439;
default: goto yy15;
}
-yy386:
- YYDEBUG(386, YYPEEK ());
+yy388:
+ YYDEBUG(388, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'S':
- case 's': goto yy439;
+ case 's': goto yy441;
default: goto yy15;
}
-yy387:
- YYDEBUG(387, YYPEEK ());
+yy389:
+ YYDEBUG(389, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy441;
+ case 'e': goto yy443;
default: goto yy15;
}
-yy388:
- YYDEBUG(388, YYPEEK ());
+yy390:
+ YYDEBUG(390, YYPEEK ());
yyaccept = 40;
YYSKIP ();
YYBACKUP ();
@@ -11126,15 +11140,15 @@ yy388:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy389;
+ default: goto yy391;
}
-yy389:
- YYDEBUG(389, YYPEEK ());
-#line 271 "../ada.re2c"
+yy391:
+ YYDEBUG(391, YYPEEK ());
+#line 278 "../ada.re2c"
{*id = 11; continue;}
-#line 11136 "../ada_re2c.c"
-yy390:
- YYDEBUG(390, YYPEEK ());
+#line 11150 "../ada_re2c.c"
+yy392:
+ YYDEBUG(392, YYPEEK ());
yyaccept = 41;
YYSKIP ();
YYBACKUP ();
@@ -11255,37 +11269,37 @@ yy390:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy391;
+ default: goto yy393;
}
-yy391:
- YYDEBUG(391, YYPEEK ());
-#line 273 "../ada.re2c"
+yy393:
+ YYDEBUG(393, YYPEEK ());
+#line 280 "../ada.re2c"
{*id = 13; continue;}
-#line 11265 "../ada_re2c.c"
-yy392:
- YYDEBUG(392, YYPEEK ());
+#line 11279 "../ada_re2c.c"
+yy394:
+ YYDEBUG(394, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'A':
- case 'a': goto yy442;
+ case 'a': goto yy444;
default: goto yy15;
}
-yy393:
- YYDEBUG(393, YYPEEK ());
+yy395:
+ YYDEBUG(395, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'R':
- case 'r': goto yy443;
+ case 'r': goto yy445;
default: goto yy15;
}
-yy394:
- YYDEBUG(394, YYPEEK ());
+yy396:
+ YYDEBUG(396, YYPEEK ());
yyaccept = 42;
YYSKIP ();
YYBACKUP ();
@@ -11406,15 +11420,15 @@ yy394:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy395;
+ default: goto yy397;
}
-yy395:
- YYDEBUG(395, YYPEEK ());
-#line 278 "../ada.re2c"
+yy397:
+ YYDEBUG(397, YYPEEK ());
+#line 285 "../ada.re2c"
{*id = 18; continue;}
-#line 11416 "../ada_re2c.c"
-yy396:
- YYDEBUG(396, YYPEEK ());
+#line 11430 "../ada_re2c.c"
+yy398:
+ YYDEBUG(398, YYPEEK ());
yyaccept = 43;
YYSKIP ();
YYBACKUP ();
@@ -11535,26 +11549,26 @@ yy396:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy397;
+ default: goto yy399;
}
-yy397:
- YYDEBUG(397, YYPEEK ());
-#line 279 "../ada.re2c"
+yy399:
+ YYDEBUG(399, YYPEEK ());
+#line 286 "../ada.re2c"
{*id = 19; continue;}
-#line 11545 "../ada_re2c.c"
-yy398:
- YYDEBUG(398, YYPEEK ());
+#line 11559 "../ada_re2c.c"
+yy400:
+ YYDEBUG(400, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'S':
- case 's': goto yy444;
+ case 's': goto yy446;
default: goto yy15;
}
-yy399:
- YYDEBUG(399, YYPEEK ());
+yy401:
+ YYDEBUG(401, YYPEEK ());
yyaccept = 44;
YYSKIP ();
YYBACKUP ();
@@ -11675,15 +11689,15 @@ yy399:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy400;
+ default: goto yy402;
}
-yy400:
- YYDEBUG(400, YYPEEK ());
-#line 283 "../ada.re2c"
+yy402:
+ YYDEBUG(402, YYPEEK ());
+#line 290 "../ada.re2c"
{*id = 23; continue;}
-#line 11685 "../ada_re2c.c"
-yy401:
- YYDEBUG(401, YYPEEK ());
+#line 11699 "../ada_re2c.c"
+yy403:
+ YYDEBUG(403, YYPEEK ());
yyaccept = 45;
YYSKIP ();
YYBACKUP ();
@@ -11804,147 +11818,147 @@ yy401:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy402;
+ default: goto yy404;
}
-yy402:
- YYDEBUG(402, YYPEEK ());
-#line 285 "../ada.re2c"
+yy404:
+ YYDEBUG(404, YYPEEK ());
+#line 292 "../ada.re2c"
{*id = 25; continue;}
-#line 11814 "../ada_re2c.c"
-yy403:
- YYDEBUG(403, YYPEEK ());
+#line 11828 "../ada_re2c.c"
+yy405:
+ YYDEBUG(405, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'T':
- case 't': goto yy446;
+ case 't': goto yy448;
default: goto yy15;
}
-yy404:
- YYDEBUG(404, YYPEEK ());
+yy406:
+ YYDEBUG(406, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'I':
- case 'i': goto yy447;
+ case 'i': goto yy449;
default: goto yy15;
}
-yy405:
- YYDEBUG(405, YYPEEK ());
+yy407:
+ YYDEBUG(407, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'I':
- case 'i': goto yy448;
+ case 'i': goto yy450;
default: goto yy15;
}
-yy406:
- YYDEBUG(406, YYPEEK ());
+yy408:
+ YYDEBUG(408, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'F':
- case 'f': goto yy449;
+ case 'f': goto yy451;
default: goto yy15;
}
-yy407:
- YYDEBUG(407, YYPEEK ());
+yy409:
+ YYDEBUG(409, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy450;
+ case 'e': goto yy452;
default: goto yy15;
}
-yy408:
- YYDEBUG(408, YYPEEK ());
+yy410:
+ YYDEBUG(410, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'S':
- case 's': goto yy451;
+ case 's': goto yy453;
default: goto yy15;
}
-yy409:
- YYDEBUG(409, YYPEEK ());
+yy411:
+ YYDEBUG(411, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'I':
- case 'i': goto yy453;
+ case 'i': goto yy455;
default: goto yy15;
}
-yy410:
- YYDEBUG(410, YYPEEK ());
+yy412:
+ YYDEBUG(412, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'G':
- case 'g': goto yy454;
+ case 'g': goto yy456;
default: goto yy15;
}
-yy411:
- YYDEBUG(411, YYPEEK ());
+yy413:
+ YYDEBUG(413, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'A':
- case 'a': goto yy455;
+ case 'a': goto yy457;
default: goto yy15;
}
-yy412:
- YYDEBUG(412, YYPEEK ());
+yy414:
+ YYDEBUG(414, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'T':
- case 't': goto yy457;
+ case 't': goto yy459;
default: goto yy15;
}
-yy413:
- YYDEBUG(413, YYPEEK ());
+yy415:
+ YYDEBUG(415, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'D':
- case 'd': goto yy458;
+ case 'd': goto yy460;
default: goto yy15;
}
-yy414:
- YYDEBUG(414, YYPEEK ());
+yy416:
+ YYDEBUG(416, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'C':
- case 'c': goto yy459;
+ case 'c': goto yy461;
default: goto yy15;
}
-yy415:
- YYDEBUG(415, YYPEEK ());
+yy417:
+ YYDEBUG(417, YYPEEK ());
yyaccept = 46;
YYSKIP ();
YYBACKUP ();
@@ -12065,15 +12079,15 @@ yy415:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy416;
+ default: goto yy418;
}
-yy416:
- YYDEBUG(416, YYPEEK ());
-#line 312 "../ada.re2c"
+yy418:
+ YYDEBUG(418, YYPEEK ());
+#line 319 "../ada.re2c"
{*id = 52; continue;}
-#line 12075 "../ada_re2c.c"
-yy417:
- YYDEBUG(417, YYPEEK ());
+#line 12089 "../ada_re2c.c"
+yy419:
+ YYDEBUG(419, YYPEEK ());
yyaccept = 47;
YYSKIP ();
YYBACKUP ();
@@ -12194,136 +12208,136 @@ yy417:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy418;
+ default: goto yy420;
}
-yy418:
- YYDEBUG(418, YYPEEK ());
-#line 313 "../ada.re2c"
+yy420:
+ YYDEBUG(420, YYPEEK ());
+#line 320 "../ada.re2c"
{*id = 53; continue;}
-#line 12204 "../ada_re2c.c"
-yy419:
- YYDEBUG(419, YYPEEK ());
+#line 12218 "../ada_re2c.c"
+yy421:
+ YYDEBUG(421, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'D':
- case 'd': goto yy460;
+ case 'd': goto yy462;
default: goto yy15;
}
-yy420:
- YYDEBUG(420, YYPEEK ());
+yy422:
+ YYDEBUG(422, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy462;
+ case 'e': goto yy464;
default: goto yy15;
}
-yy421:
- YYDEBUG(421, YYPEEK ());
+yy423:
+ YYDEBUG(423, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'U':
- case 'u': goto yy463;
+ case 'u': goto yy465;
default: goto yy15;
}
-yy422:
- YYDEBUG(422, YYPEEK ());
+yy424:
+ YYDEBUG(424, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'N':
- case 'n': goto yy464;
+ case 'n': goto yy466;
default: goto yy15;
}
-yy423:
- YYDEBUG(423, YYPEEK ());
+yy425:
+ YYDEBUG(425, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'S':
- case 's': goto yy466;
+ case 's': goto yy468;
default: goto yy15;
}
-yy424:
- YYDEBUG(424, YYPEEK ());
+yy426:
+ YYDEBUG(426, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'T':
- case 't': goto yy467;
+ case 't': goto yy469;
default: goto yy15;
}
-yy425:
- YYDEBUG(425, YYPEEK ());
+yy427:
+ YYDEBUG(427, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'A':
- case 'a': goto yy469;
+ case 'a': goto yy471;
default: goto yy15;
}
-yy426:
- YYDEBUG(426, YYPEEK ());
+yy428:
+ YYDEBUG(428, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'P':
- case 'p': goto yy470;
+ case 'p': goto yy472;
default: goto yy15;
}
-yy427:
- YYDEBUG(427, YYPEEK ());
+yy429:
+ YYDEBUG(429, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'R':
- case 'r': goto yy471;
+ case 'r': goto yy473;
default: goto yy15;
}
-yy428:
- YYDEBUG(428, YYPEEK ());
+yy430:
+ YYDEBUG(430, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'D':
- case 'd': goto yy472;
+ case 'd': goto yy474;
default: goto yy15;
}
-yy429:
- YYDEBUG(429, YYPEEK ());
+yy431:
+ YYDEBUG(431, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'N':
- case 'n': goto yy474;
+ case 'n': goto yy476;
default: goto yy15;
}
-yy430:
- YYDEBUG(430, YYPEEK ());
+yy432:
+ YYDEBUG(432, YYPEEK ());
yyaccept = 48;
YYSKIP ();
YYBACKUP ();
@@ -12444,15 +12458,15 @@ yy430:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy431;
+ default: goto yy433;
}
-yy431:
- YYDEBUG(431, YYPEEK ());
-#line 330 "../ada.re2c"
+yy433:
+ YYDEBUG(433, YYPEEK ());
+#line 337 "../ada.re2c"
{*id = 70; continue;}
-#line 12454 "../ada_re2c.c"
-yy432:
- YYDEBUG(432, YYPEEK ());
+#line 12468 "../ada_re2c.c"
+yy434:
+ YYDEBUG(434, YYPEEK ());
yyaccept = 49;
YYSKIP ();
YYBACKUP ();
@@ -12573,21 +12587,21 @@ yy432:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy433;
+ default: goto yy435;
}
-yy433:
- YYDEBUG(433, YYPEEK ());
-#line 333 "../ada.re2c"
+yy435:
+ YYDEBUG(435, YYPEEK ());
+#line 340 "../ada.re2c"
{*id = 73; continue;}
-#line 12583 "../ada_re2c.c"
-yy434:
- YYDEBUG(434, YYPEEK ());
+#line 12597 "../ada_re2c.c"
+yy436:
+ YYDEBUG(436, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
-yy435:
- YYDEBUG(435, YYPEEK ());
+yy437:
+ YYDEBUG(437, YYPEEK ());
switch (yych) {
- case '"': goto yy475;
+ case '"': goto yy477;
case '0':
case '1':
case '2':
@@ -12609,22 +12623,22 @@ yy435:
case 'c':
case 'd':
case 'e':
- case 'f': goto yy434;
- default: goto yy81;
+ case 'f': goto yy436;
+ default: goto yy83;
}
-yy436:
- YYDEBUG(436, YYPEEK ());
+yy438:
+ YYDEBUG(438, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'C':
- case 'c': goto yy476;
+ case 'c': goto yy478;
default: goto yy15;
}
-yy437:
- YYDEBUG(437, YYPEEK ());
+yy439:
+ YYDEBUG(439, YYPEEK ());
yyaccept = 50;
YYSKIP ();
YYBACKUP ();
@@ -12745,15 +12759,15 @@ yy437:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy438;
+ default: goto yy440;
}
-yy438:
- YYDEBUG(438, YYPEEK ());
-#line 264 "../ada.re2c"
+yy440:
+ YYDEBUG(440, YYPEEK ());
+#line 271 "../ada.re2c"
{*id = 4; continue;}
-#line 12755 "../ada_re2c.c"
-yy439:
- YYDEBUG(439, YYPEEK ());
+#line 12769 "../ada_re2c.c"
+yy441:
+ YYDEBUG(441, YYPEEK ());
yyaccept = 51;
YYSKIP ();
YYBACKUP ();
@@ -12874,48 +12888,48 @@ yy439:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy440;
+ default: goto yy442;
}
-yy440:
- YYDEBUG(440, YYPEEK ());
-#line 267 "../ada.re2c"
+yy442:
+ YYDEBUG(442, YYPEEK ());
+#line 274 "../ada.re2c"
{*id = 7; continue;}
-#line 12884 "../ada_re2c.c"
-yy441:
- YYDEBUG(441, YYPEEK ());
+#line 12898 "../ada_re2c.c"
+yy443:
+ YYDEBUG(443, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'D':
- case 'd': goto yy477;
+ case 'd': goto yy479;
default: goto yy15;
}
-yy442:
- YYDEBUG(442, YYPEEK ());
+yy444:
+ YYDEBUG(444, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'N':
- case 'n': goto yy479;
+ case 'n': goto yy481;
default: goto yy15;
}
-yy443:
- YYDEBUG(443, YYPEEK ());
+yy445:
+ YYDEBUG(445, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy480;
+ case 'e': goto yy482;
default: goto yy15;
}
-yy444:
- YYDEBUG(444, YYPEEK ());
+yy446:
+ YYDEBUG(446, YYPEEK ());
yyaccept = 52;
YYSKIP ();
YYBACKUP ();
@@ -13036,70 +13050,70 @@ yy444:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy445;
+ default: goto yy447;
}
-yy445:
- YYDEBUG(445, YYPEEK ());
-#line 280 "../ada.re2c"
+yy447:
+ YYDEBUG(447, YYPEEK ());
+#line 287 "../ada.re2c"
{*id = 20; continue;}
-#line 13046 "../ada_re2c.c"
-yy446:
- YYDEBUG(446, YYPEEK ());
+#line 13060 "../ada_re2c.c"
+yy448:
+ YYDEBUG(448, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'I':
- case 'i': goto yy482;
+ case 'i': goto yy484;
default: goto yy15;
}
-yy447:
- YYDEBUG(447, YYPEEK ());
+yy449:
+ YYDEBUG(449, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'O':
- case 'o': goto yy483;
+ case 'o': goto yy485;
default: goto yy15;
}
-yy448:
- YYDEBUG(448, YYPEEK ());
+yy450:
+ YYDEBUG(450, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'C':
- case 'c': goto yy484;
+ case 'c': goto yy486;
default: goto yy15;
}
-yy449:
- YYDEBUG(449, YYPEEK ());
+yy451:
+ YYDEBUG(451, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'A':
- case 'a': goto yy486;
+ case 'a': goto yy488;
default: goto yy15;
}
-yy450:
- YYDEBUG(450, YYPEEK ());
+yy452:
+ YYDEBUG(452, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'D':
- case 'd': goto yy487;
+ case 'd': goto yy489;
default: goto yy15;
}
-yy451:
- YYDEBUG(451, YYPEEK ());
+yy453:
+ YYDEBUG(453, YYPEEK ());
yyaccept = 53;
YYSKIP ();
YYBACKUP ();
@@ -13220,37 +13234,37 @@ yy451:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy452;
+ default: goto yy454;
}
-yy452:
- YYDEBUG(452, YYPEEK ());
-#line 304 "../ada.re2c"
+yy454:
+ YYDEBUG(454, YYPEEK ());
+#line 311 "../ada.re2c"
{*id = 44; continue;}
-#line 13230 "../ada_re2c.c"
-yy453:
- YYDEBUG(453, YYPEEK ());
+#line 13244 "../ada_re2c.c"
+yy455:
+ YYDEBUG(455, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'D':
- case 'd': goto yy489;
+ case 'd': goto yy491;
default: goto yy15;
}
-yy454:
- YYDEBUG(454, YYPEEK ());
+yy456:
+ YYDEBUG(456, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy490;
+ case 'e': goto yy492;
default: goto yy15;
}
-yy455:
- YYDEBUG(455, YYPEEK ());
+yy457:
+ YYDEBUG(457, YYPEEK ());
yyaccept = 54;
YYSKIP ();
YYBACKUP ();
@@ -13371,48 +13385,48 @@ yy455:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy456;
+ default: goto yy458;
}
-yy456:
- YYDEBUG(456, YYPEEK ());
-#line 308 "../ada.re2c"
+yy458:
+ YYDEBUG(458, YYPEEK ());
+#line 315 "../ada.re2c"
{*id = 48; continue;}
-#line 13381 "../ada_re2c.c"
-yy457:
- YYDEBUG(457, YYPEEK ());
+#line 13395 "../ada_re2c.c"
+yy459:
+ YYDEBUG(459, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy492;
+ case 'e': goto yy494;
default: goto yy15;
}
-yy458:
- YYDEBUG(458, YYPEEK ());
+yy460:
+ YYDEBUG(460, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'U':
- case 'u': goto yy494;
+ case 'u': goto yy496;
default: goto yy15;
}
-yy459:
- YYDEBUG(459, YYPEEK ());
+yy461:
+ YYDEBUG(461, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'T':
- case 't': goto yy495;
+ case 't': goto yy497;
default: goto yy15;
}
-yy460:
- YYDEBUG(460, YYPEEK ());
+yy462:
+ YYDEBUG(462, YYPEEK ());
yyaccept = 55;
YYSKIP ();
YYBACKUP ();
@@ -13533,37 +13547,37 @@ yy460:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy461;
+ default: goto yy463;
}
-yy461:
- YYDEBUG(461, YYPEEK ());
-#line 314 "../ada.re2c"
+yy463:
+ YYDEBUG(463, YYPEEK ());
+#line 321 "../ada.re2c"
{*id = 54; continue;}
-#line 13543 "../ada_re2c.c"
-yy462:
- YYDEBUG(462, YYPEEK ());
+#line 13557 "../ada_re2c.c"
+yy464:
+ YYDEBUG(464, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'S':
- case 's': goto yy496;
+ case 's': goto yy498;
default: goto yy15;
}
-yy463:
- YYDEBUG(463, YYPEEK ());
+yy465:
+ YYDEBUG(465, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy498;
+ case 'e': goto yy500;
default: goto yy15;
}
-yy464:
- YYDEBUG(464, YYPEEK ());
+yy466:
+ YYDEBUG(466, YYPEEK ());
yyaccept = 56;
YYSKIP ();
YYBACKUP ();
@@ -13684,26 +13698,26 @@ yy464:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy465;
+ default: goto yy467;
}
-yy465:
- YYDEBUG(465, YYPEEK ());
-#line 318 "../ada.re2c"
+yy467:
+ YYDEBUG(467, YYPEEK ());
+#line 325 "../ada.re2c"
{*id = 58; continue;}
-#line 13694 "../ada_re2c.c"
-yy466:
- YYDEBUG(466, YYPEEK ());
+#line 13708 "../ada_re2c.c"
+yy468:
+ YYDEBUG(468, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy500;
+ case 'e': goto yy502;
default: goto yy15;
}
-yy467:
- YYDEBUG(467, YYPEEK ());
+yy469:
+ YYDEBUG(469, YYPEEK ());
yyaccept = 57;
YYSKIP ();
YYBACKUP ();
@@ -13824,48 +13838,48 @@ yy467:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy468;
+ default: goto yy470;
}
-yy468:
- YYDEBUG(468, YYPEEK ());
-#line 321 "../ada.re2c"
+yy470:
+ YYDEBUG(470, YYPEEK ());
+#line 328 "../ada.re2c"
{*id = 61; continue;}
-#line 13834 "../ada_re2c.c"
-yy469:
- YYDEBUG(469, YYPEEK ());
+#line 13848 "../ada_re2c.c"
+yy471:
+ YYDEBUG(471, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'T':
- case 't': goto yy502;
+ case 't': goto yy504;
default: goto yy15;
}
-yy470:
- YYDEBUG(470, YYPEEK ());
+yy472:
+ YYDEBUG(472, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy503;
+ case 'e': goto yy505;
default: goto yy15;
}
-yy471:
- YYDEBUG(471, YYPEEK ());
+yy473:
+ YYDEBUG(473, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'O':
- case 'o': goto yy505;
+ case 'o': goto yy507;
default: goto yy15;
}
-yy472:
- YYDEBUG(472, YYPEEK ());
+yy474:
+ YYDEBUG(474, YYPEEK ());
yyaccept = 58;
YYSKIP ();
YYBACKUP ();
@@ -13986,45 +14000,45 @@ yy472:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy473;
+ default: goto yy475;
}
-yy473:
- YYDEBUG(473, YYPEEK ());
-#line 325 "../ada.re2c"
+yy475:
+ YYDEBUG(475, YYPEEK ());
+#line 332 "../ada.re2c"
{*id = 65; continue;}
-#line 13996 "../ada_re2c.c"
-yy474:
- YYDEBUG(474, YYPEEK ());
+#line 14010 "../ada_re2c.c"
+yy476:
+ YYDEBUG(476, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'A':
- case 'a': goto yy506;
+ case 'a': goto yy508;
default: goto yy15;
}
-yy475:
- YYDEBUG(475, YYPEEK ());
+yy477:
+ YYDEBUG(477, YYPEEK ());
YYSKIP ();
yych = YYPEEK ();
switch (yych) {
- case ']': goto yy299;
- default: goto yy81;
+ case ']': goto yy301;
+ default: goto yy83;
}
-yy476:
- YYDEBUG(476, YYPEEK ());
+yy478:
+ YYDEBUG(478, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'T':
- case 't': goto yy507;
+ case 't': goto yy509;
default: goto yy15;
}
-yy477:
- YYDEBUG(477, YYPEEK ());
+yy479:
+ YYDEBUG(479, YYPEEK ());
yyaccept = 59;
YYSKIP ();
YYBACKUP ();
@@ -14145,26 +14159,26 @@ yy477:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy478;
+ default: goto yy480;
}
-yy478:
- YYDEBUG(478, YYPEEK ());
-#line 268 "../ada.re2c"
+yy480:
+ YYDEBUG(480, YYPEEK ());
+#line 275 "../ada.re2c"
{*id = 8; continue;}
-#line 14155 "../ada_re2c.c"
-yy479:
- YYDEBUG(479, YYPEEK ());
+#line 14169 "../ada_re2c.c"
+yy481:
+ YYDEBUG(481, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'T':
- case 't': goto yy509;
+ case 't': goto yy511;
default: goto yy15;
}
-yy480:
- YYDEBUG(480, YYPEEK ());
+yy482:
+ YYDEBUG(482, YYPEEK ());
yyaccept = 60;
YYSKIP ();
YYBACKUP ();
@@ -14285,37 +14299,37 @@ yy480:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy481;
+ default: goto yy483;
}
-yy481:
- YYDEBUG(481, YYPEEK ());
-#line 277 "../ada.re2c"
+yy483:
+ YYDEBUG(483, YYPEEK ());
+#line 284 "../ada.re2c"
{*id = 17; continue;}
-#line 14295 "../ada_re2c.c"
-yy482:
- YYDEBUG(482, YYPEEK ());
+#line 14309 "../ada_re2c.c"
+yy484:
+ YYDEBUG(484, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'O':
- case 'o': goto yy511;
+ case 'o': goto yy513;
default: goto yy15;
}
-yy483:
- YYDEBUG(483, YYPEEK ());
+yy485:
+ YYDEBUG(485, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'N':
- case 'n': goto yy512;
+ case 'n': goto yy514;
default: goto yy15;
}
-yy484:
- YYDEBUG(484, YYPEEK ());
+yy486:
+ YYDEBUG(486, YYPEEK ());
yyaccept = 61;
YYSKIP ();
YYBACKUP ();
@@ -14436,26 +14450,26 @@ yy484:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy485;
+ default: goto yy487;
}
-yy485:
- YYDEBUG(485, YYPEEK ());
-#line 290 "../ada.re2c"
+yy487:
+ YYDEBUG(487, YYPEEK ());
+#line 297 "../ada.re2c"
{*id = 30; continue;}
-#line 14446 "../ada_re2c.c"
-yy486:
- YYDEBUG(486, YYPEEK ());
+#line 14460 "../ada_re2c.c"
+yy488:
+ YYDEBUG(488, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'C':
- case 'c': goto yy514;
+ case 'c': goto yy516;
default: goto yy15;
}
-yy487:
- YYDEBUG(487, YYPEEK ());
+yy489:
+ YYDEBUG(489, YYPEEK ());
yyaccept = 62;
YYSKIP ();
YYBACKUP ();
@@ -14576,26 +14590,26 @@ yy487:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy488;
+ default: goto yy490;
}
-yy488:
- YYDEBUG(488, YYPEEK ());
-#line 296 "../ada.re2c"
+yy490:
+ YYDEBUG(490, YYPEEK ());
+#line 303 "../ada.re2c"
{*id = 36; continue;}
-#line 14586 "../ada_re2c.c"
-yy489:
- YYDEBUG(489, YYPEEK ());
+#line 14600 "../ada_re2c.c"
+yy491:
+ YYDEBUG(491, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'I':
- case 'i': goto yy515;
+ case 'i': goto yy517;
default: goto yy15;
}
-yy490:
- YYDEBUG(490, YYPEEK ());
+yy492:
+ YYDEBUG(492, YYPEEK ());
yyaccept = 63;
YYSKIP ();
YYBACKUP ();
@@ -14716,15 +14730,15 @@ yy490:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy491;
+ default: goto yy493;
}
-yy491:
- YYDEBUG(491, YYPEEK ());
-#line 307 "../ada.re2c"
+yy493:
+ YYDEBUG(493, YYPEEK ());
+#line 314 "../ada.re2c"
{*id = 47; continue;}
-#line 14726 "../ada_re2c.c"
-yy492:
- YYDEBUG(492, YYPEEK ());
+#line 14740 "../ada_re2c.c"
+yy494:
+ YYDEBUG(494, YYPEEK ());
yyaccept = 64;
YYSKIP ();
YYBACKUP ();
@@ -14845,37 +14859,37 @@ yy492:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy493;
+ default: goto yy495;
}
-yy493:
- YYDEBUG(493, YYPEEK ());
-#line 309 "../ada.re2c"
+yy495:
+ YYDEBUG(495, YYPEEK ());
+#line 316 "../ada.re2c"
{*id = 49; continue;}
-#line 14855 "../ada_re2c.c"
-yy494:
- YYDEBUG(494, YYPEEK ());
+#line 14869 "../ada_re2c.c"
+yy496:
+ YYDEBUG(496, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'R':
- case 'r': goto yy516;
+ case 'r': goto yy518;
default: goto yy15;
}
-yy495:
- YYDEBUG(495, YYPEEK ());
+yy497:
+ YYDEBUG(497, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy517;
+ case 'e': goto yy519;
default: goto yy15;
}
-yy496:
- YYDEBUG(496, YYPEEK ());
+yy498:
+ YYDEBUG(498, YYPEEK ());
yyaccept = 65;
YYSKIP ();
YYBACKUP ();
@@ -14996,15 +15010,15 @@ yy496:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy497;
+ default: goto yy499;
}
-yy497:
- YYDEBUG(497, YYPEEK ());
-#line 316 "../ada.re2c"
+yy499:
+ YYDEBUG(499, YYPEEK ());
+#line 323 "../ada.re2c"
{*id = 56; continue;}
-#line 15006 "../ada_re2c.c"
-yy498:
- YYDEBUG(498, YYPEEK ());
+#line 15020 "../ada_re2c.c"
+yy500:
+ YYDEBUG(500, YYPEEK ());
yyaccept = 66;
YYSKIP ();
YYBACKUP ();
@@ -15125,15 +15139,15 @@ yy498:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy499;
+ default: goto yy501;
}
-yy499:
- YYDEBUG(499, YYPEEK ());
-#line 317 "../ada.re2c"
+yy501:
+ YYDEBUG(501, YYPEEK ());
+#line 324 "../ada.re2c"
{*id = 57; continue;}
-#line 15135 "../ada_re2c.c"
-yy500:
- YYDEBUG(500, YYPEEK ());
+#line 15149 "../ada_re2c.c"
+yy502:
+ YYDEBUG(502, YYPEEK ());
yyaccept = 67;
YYSKIP ();
YYBACKUP ();
@@ -15254,26 +15268,26 @@ yy500:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy501;
+ default: goto yy503;
}
-yy501:
- YYDEBUG(501, YYPEEK ());
-#line 319 "../ada.re2c"
+yy503:
+ YYDEBUG(503, YYPEEK ());
+#line 326 "../ada.re2c"
{*id = 59; continue;}
-#line 15264 "../ada_re2c.c"
-yy502:
- YYDEBUG(502, YYPEEK ());
+#line 15278 "../ada_re2c.c"
+yy504:
+ YYDEBUG(504, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy518;
+ case 'e': goto yy520;
default: goto yy15;
}
-yy503:
- YYDEBUG(503, YYPEEK ());
+yy505:
+ YYDEBUG(505, YYPEEK ());
yyaccept = 68;
YYSKIP ();
YYBACKUP ();
@@ -15394,37 +15408,37 @@ yy503:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy504;
+ default: goto yy506;
}
-yy504:
- YYDEBUG(504, YYPEEK ());
-#line 323 "../ada.re2c"
+yy506:
+ YYDEBUG(506, YYPEEK ());
+#line 330 "../ada.re2c"
{*id = 63; continue;}
-#line 15404 "../ada_re2c.c"
-yy505:
- YYDEBUG(505, YYPEEK ());
+#line 15418 "../ada_re2c.c"
+yy507:
+ YYDEBUG(507, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'N':
- case 'n': goto yy520;
+ case 'n': goto yy522;
default: goto yy15;
}
-yy506:
- YYDEBUG(506, YYPEEK ());
+yy508:
+ YYDEBUG(508, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'T':
- case 't': goto yy521;
+ case 't': goto yy523;
default: goto yy15;
}
-yy507:
- YYDEBUG(507, YYPEEK ());
+yy509:
+ YYDEBUG(509, YYPEEK ());
yyaccept = 69;
YYSKIP ();
YYBACKUP ();
@@ -15545,15 +15559,15 @@ yy507:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy508;
+ default: goto yy510;
}
-yy508:
- YYDEBUG(508, YYPEEK ());
-#line 266 "../ada.re2c"
+yy510:
+ YYDEBUG(510, YYPEEK ());
+#line 273 "../ada.re2c"
{*id = 6; continue;}
-#line 15555 "../ada_re2c.c"
-yy509:
- YYDEBUG(509, YYPEEK ());
+#line 15569 "../ada_re2c.c"
+yy511:
+ YYDEBUG(511, YYPEEK ());
yyaccept = 70;
YYSKIP ();
YYBACKUP ();
@@ -15674,26 +15688,26 @@ yy509:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy510;
+ default: goto yy512;
}
-yy510:
- YYDEBUG(510, YYPEEK ());
-#line 276 "../ada.re2c"
+yy512:
+ YYDEBUG(512, YYPEEK ());
+#line 283 "../ada.re2c"
{*id = 16; continue;}
-#line 15684 "../ada_re2c.c"
-yy511:
- YYDEBUG(511, YYPEEK ());
+#line 15698 "../ada_re2c.c"
+yy513:
+ YYDEBUG(513, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'N':
- case 'n': goto yy522;
+ case 'n': goto yy524;
default: goto yy15;
}
-yy512:
- YYDEBUG(512, YYPEEK ());
+yy514:
+ YYDEBUG(514, YYPEEK ());
yyaccept = 71;
YYSKIP ();
YYBACKUP ();
@@ -15814,59 +15828,59 @@ yy512:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy513;
+ default: goto yy515;
}
-yy513:
- YYDEBUG(513, YYPEEK ());
-#line 289 "../ada.re2c"
+yy515:
+ YYDEBUG(515, YYPEEK ());
+#line 296 "../ada.re2c"
{*id = 29; continue;}
-#line 15824 "../ada_re2c.c"
-yy514:
- YYDEBUG(514, YYPEEK ());
+#line 15838 "../ada_re2c.c"
+yy516:
+ YYDEBUG(516, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy524;
+ case 'e': goto yy526;
default: goto yy15;
}
-yy515:
- YYDEBUG(515, YYPEEK ());
+yy517:
+ YYDEBUG(517, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'N':
- case 'n': goto yy526;
+ case 'n': goto yy528;
default: goto yy15;
}
-yy516:
- YYDEBUG(516, YYPEEK ());
+yy518:
+ YYDEBUG(518, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy527;
+ case 'e': goto yy529;
default: goto yy15;
}
-yy517:
- YYDEBUG(517, YYPEEK ());
+yy519:
+ YYDEBUG(519, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'D':
- case 'd': goto yy529;
+ case 'd': goto yy531;
default: goto yy15;
}
-yy518:
- YYDEBUG(518, YYPEEK ());
+yy520:
+ YYDEBUG(520, YYPEEK ());
yyaccept = 72;
YYSKIP ();
YYBACKUP ();
@@ -15987,37 +16001,37 @@ yy518:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy519;
+ default: goto yy521;
}
-yy519:
- YYDEBUG(519, YYPEEK ());
-#line 320 "../ada.re2c"
+yy521:
+ YYDEBUG(521, YYPEEK ());
+#line 327 "../ada.re2c"
{*id = 60; continue;}
-#line 15997 "../ada_re2c.c"
-yy520:
- YYDEBUG(520, YYPEEK ());
+#line 16011 "../ada_re2c.c"
+yy522:
+ YYDEBUG(522, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'I':
- case 'i': goto yy531;
+ case 'i': goto yy533;
default: goto yy15;
}
-yy521:
- YYDEBUG(521, YYPEEK ());
+yy523:
+ YYDEBUG(523, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy532;
+ case 'e': goto yy534;
default: goto yy15;
}
-yy522:
- YYDEBUG(522, YYPEEK ());
+yy524:
+ YYDEBUG(524, YYPEEK ());
yyaccept = 73;
YYSKIP ();
YYBACKUP ();
@@ -16138,15 +16152,15 @@ yy522:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy523;
+ default: goto yy525;
}
-yy523:
- YYDEBUG(523, YYPEEK ());
-#line 286 "../ada.re2c"
+yy525:
+ YYDEBUG(525, YYPEEK ());
+#line 293 "../ada.re2c"
{*id = 26; continue;}
-#line 16148 "../ada_re2c.c"
-yy524:
- YYDEBUG(524, YYPEEK ());
+#line 16162 "../ada_re2c.c"
+yy526:
+ YYDEBUG(526, YYPEEK ());
yyaccept = 74;
YYSKIP ();
YYBACKUP ();
@@ -16267,26 +16281,26 @@ yy524:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy525;
+ default: goto yy527;
}
-yy525:
- YYDEBUG(525, YYPEEK ());
-#line 294 "../ada.re2c"
+yy527:
+ YYDEBUG(527, YYPEEK ());
+#line 301 "../ada.re2c"
{*id = 34; continue;}
-#line 16277 "../ada_re2c.c"
-yy526:
- YYDEBUG(526, YYPEEK ());
+#line 16291 "../ada_re2c.c"
+yy528:
+ YYDEBUG(528, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'G':
- case 'g': goto yy534;
+ case 'g': goto yy536;
default: goto yy15;
}
-yy527:
- YYDEBUG(527, YYPEEK ());
+yy529:
+ YYDEBUG(529, YYPEEK ());
yyaccept = 75;
YYSKIP ();
YYBACKUP ();
@@ -16407,15 +16421,15 @@ yy527:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy528;
+ default: goto yy530;
}
-yy528:
- YYDEBUG(528, YYPEEK ());
-#line 310 "../ada.re2c"
+yy530:
+ YYDEBUG(530, YYPEEK ());
+#line 317 "../ada.re2c"
{*id = 50; continue;}
-#line 16417 "../ada_re2c.c"
-yy529:
- YYDEBUG(529, YYPEEK ());
+#line 16431 "../ada_re2c.c"
+yy531:
+ YYDEBUG(531, YYPEEK ());
yyaccept = 76;
YYSKIP ();
YYBACKUP ();
@@ -16536,26 +16550,26 @@ yy529:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy530;
+ default: goto yy532;
}
-yy530:
- YYDEBUG(530, YYPEEK ());
-#line 311 "../ada.re2c"
+yy532:
+ YYDEBUG(532, YYPEEK ());
+#line 318 "../ada.re2c"
{*id = 51; continue;}
-#line 16546 "../ada_re2c.c"
-yy531:
- YYDEBUG(531, YYPEEK ());
+#line 16560 "../ada_re2c.c"
+yy533:
+ YYDEBUG(533, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'Z':
- case 'z': goto yy536;
+ case 'z': goto yy538;
default: goto yy15;
}
-yy532:
- YYDEBUG(532, YYPEEK ());
+yy534:
+ YYDEBUG(534, YYPEEK ());
yyaccept = 77;
YYSKIP ();
YYBACKUP ();
@@ -16676,15 +16690,15 @@ yy532:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy533;
+ default: goto yy535;
}
-yy533:
- YYDEBUG(533, YYPEEK ());
-#line 327 "../ada.re2c"
+yy535:
+ YYDEBUG(535, YYPEEK ());
+#line 334 "../ada.re2c"
{*id = 67; continue;}
-#line 16686 "../ada_re2c.c"
-yy534:
- YYDEBUG(534, YYPEEK ());
+#line 16700 "../ada_re2c.c"
+yy536:
+ YYDEBUG(536, YYPEEK ());
yyaccept = 78;
YYSKIP ();
YYBACKUP ();
@@ -16805,37 +16819,37 @@ yy534:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy535;
+ default: goto yy537;
}
-yy535:
- YYDEBUG(535, YYPEEK ());
-#line 306 "../ada.re2c"
+yy537:
+ YYDEBUG(537, YYPEEK ());
+#line 313 "../ada.re2c"
{*id = 46; continue;}
-#line 16815 "../ada_re2c.c"
-yy536:
- YYDEBUG(536, YYPEEK ());
+#line 16829 "../ada_re2c.c"
+yy538:
+ YYDEBUG(538, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'E':
- case 'e': goto yy537;
+ case 'e': goto yy539;
default: goto yy15;
}
-yy537:
- YYDEBUG(537, YYPEEK ());
+yy539:
+ YYDEBUG(539, YYPEEK ());
yyaccept = 1;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
switch (yych) {
case 'D':
- case 'd': goto yy538;
+ case 'd': goto yy540;
default: goto yy15;
}
-yy538:
- YYDEBUG(538, YYPEEK ());
+yy540:
+ YYDEBUG(540, YYPEEK ());
yyaccept = 79;
YYSKIP ();
YYBACKUP ();
@@ -16956,24 +16970,22 @@ yy538:
case 0xF2:
case 0xF3:
case 0xF4: goto yy15;
- default: goto yy539;
+ default: goto yy541;
}
-yy539:
- YYDEBUG(539, YYPEEK ());
-#line 324 "../ada.re2c"
+yy541:
+ YYDEBUG(541, YYPEEK ());
+#line 331 "../ada.re2c"
{*id = 64; continue;}
-#line 16966 "../ada_re2c.c"
+#line 16980 "../ada_re2c.c"
}
-#line 370 "../ada.re2c"
+#line 378 "../ada.re2c"
- }
+ }
+ /* lexer->cursor and lexer ->char_pos are one char past end of token */
*byte_position = lexer->byte_token_start - lexer->buffer + 1;
*byte_length = lexer->cursor - lexer->byte_token_start;
*char_position = lexer->char_token_start;
- if (DO_COUNT)
- *char_length = lexer->char_pos - lexer->char_token_start;
- else
- *char_length = lexer->char_pos - lexer->char_token_start + 1;
- *line_start = lexer->line_token_start;
+ *char_length = lexer->char_pos - lexer->char_token_start;
+ *line_start = lexer->line_token_start;
return status;
}
diff --git a/packages/ada-mode/build.sh b/packages/ada-mode/build.sh
index 47cbb4d..ced5c37 100755
--- a/packages/ada-mode/build.sh
+++ b/packages/ada-mode/build.sh
@@ -1,5 +1,7 @@
#!/bin/sh
-# Build and install executables for Ada mode.
+# Build executables for Ada mode.
+#
+# See install.sh for install
# In December 2016, GNATCOLL changed its Xref interface. First, the
# GPR was split out; and second, one of the subprogram
@@ -13,18 +15,15 @@ if test $? -eq 0 ; then HAVE_GNATCOLL_XREF="yes"; else
HAVE_GNATCOLL_XREF="no";
echo "HAVE_GNATCOLL_XREF=$HAVE_GNATCOLL_XREF"
gnatprep -DHAVE_GNATCOLL_XREF=$HAVE_GNATCOLL_XREF
gpr_query-process_refresh.adb.gp gpr_query-process_refresh.adb
-gnatprep -DHAVE_GNATCOLL_XREF=$HAVE_GNATCOLL_XREF gpr_query.gpr.gp
gpr_query.gpr
# support for libadalang is still experimental
-gnatprep -DHAVE_LIBADALANG="no" -DELPA="yes" ada_mode_wisi_parse.gpr.gp
ada_mode_wisi_parse.gpr
+gnatprep -DHAVE_GNATCOLL_XREF=$HAVE_GNATCOLL_XREF -DHAVE_LIBADALANG="no"
-DELPA="yes" ada_mode_wisi_parse.gpr.gp ada_mode_wisi_parse.gpr
-export GPR_PROJECT_PATH="../wisi-2.2.1"
+export GPR_PROJECT_PATH="../wisi-3.0.1"
-gprbuild -p -P gpr_query.gpr
-gprinstall -f -p -P gpr_query.gpr --install-name=gpr_query
+gnatprep -DELPA="yes" $GPR_PROJECT_PATH/wisi.gpr.gp $GPR_PROJECT_PATH/wisi.gpr
-gprbuild -p -P ada_mode_wisi_parse.gpr
+gprbuild -p -j8 -P ada_mode_wisi_parse.gpr
gzip -d -q ada_lr1_parse_table.txt.gz
-gprinstall -f -p -P ada_mode_wisi_parse.gpr --install-name=ada_mode_wisi_parse
# end of file
diff --git a/packages/ada-mode/dir b/packages/ada-mode/dir
index 3af5cd0..4c07b01 100644
--- a/packages/ada-mode/dir
+++ b/packages/ada-mode/dir
@@ -16,11 +16,7 @@ File: dir, Node: Top This is the top of the INFO tree
Emacs
* Ada mode: (ada-mode). Emacs mode for editing and navigating Ada code.
-* Wisi: (wisi). Package providing error-correcting LR parsers.
-* gpr mode: (gpr-mode). Emacs mode for editing and navigating gpr
- files (gnat project files).
-
-Emacs editing modes
-* Ada mode: (ada-mode). Emacs mode for editing and navigating Ada code.
+* Wisi: (wisi). Error-correcting LR parsers and project
+ integration.
* gpr mode: (gpr-mode). Emacs mode for editing and navigating gpr
files (gnat project files).
diff --git a/packages/ada-mode/gnat-core.el b/packages/ada-mode/gnat-core.el
index d65a500..798c993 100644
--- a/packages/ada-mode/gnat-core.el
+++ b/packages/ada-mode/gnat-core.el
@@ -24,14 +24,12 @@
;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
(require 'cl-lib)
-(require 'ada-mode) ;; for ada-prj-* etc; will be refactored sometime
-
-(defvar gpr-query--sessions nil) ;; gpr-query.el
-(declare-function gpr-query-kill-session "gpr-query.el" (session) )
+(require 'wisi-prj)
;;;;; code
(defcustom ada-gnat-debug-run nil
+ ;; Name implies Ada, which is wrong. Kept for backward compatibility.
"If t, compilation buffers containing a GNAT command will show
the command. Otherwise, they will show only the output of the
command. This applies e.g. to *gnatfind* buffers."
@@ -41,114 +39,82 @@ command. This applies e.g. to *gnatfind* buffers."
;;;; 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)
- (cl-pushnew dir prj-dir :test #'equal))
-
- (prj-dir
- (setq prj-dir (list dir)))
-
- (t nil))
-
- (setq project (plist-put project 'prj_dir prj-dir))
-
- (let ((process-environment (cl-copy-list (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 (cl-copy-list
process-environment)))
- )
+(cl-defstruct gnat-compiler
+ "Used with wisi-compiler-* generic functions."
- project))
+ gpr-file ;; absolute file name of GNAT project file.
+ run-buffer-name ;; string; some compiler objects have no gpr file
+ project-path ;; list of directories from GPR_PROJECT_PATH
+ target ;; gnat --target argument.
+ runtime ;; gnat --RTS argument.
+ gnat-stub-opts ;; options for gnat stub
+ gnat-stub-cargs ;; cargs options for gnat stub
+ )
-(defun gnat-prj-show-prj-path ()
- "For `ada-prj-show-prj-path'."
- (interactive)
- (if (ada-prj-get 'prj_dir)
- (progn
- (pop-to-buffer (get-buffer-create "*GNAT project file search path*"))
- (erase-buffer)
- (dolist (file (ada-prj-get 'prj_dir))
- (insert (format "%s\n" file))))
- (message "no project file search path set")
+;;;###autoload
+(cl-defun create-gnat-compiler
+ (&key
+ gpr-file
+ run-buffer-name
+ project-path
+ target
+ runtime
+ gnat-stub-opts
+ gnat-stub-cargs)
+ ;; See note on `create-ada-prj' for why this is not a defalias.
+ (make-gnat-compiler
+ :gpr-file gpr-file
+ :run-buffer-name run-buffer-name
+ :project-path project-path
+ :target target
+ :runtime runtime
+ :gnat-stub-opts gnat-stub-opts
+ :gnat-stub-cargs gnat-stub-cargs
+ ))
+
+(defun gnat-compiler-require-prj ()
+ "Return current `gnat-compiler' object from current project compiler.
+Throw an error if current project does not have a gnat-compiler."
+ (let* ((wisi-prj (wisi-prj-require-prj))
+ (compiler (wisi-prj-compiler wisi-prj)))
+ (if (gnat-compiler-p compiler)
+ compiler
+ (error "no gnat-compiler in current project"))))
+
+(defun gnat-prj-add-prj-dir (project dir)
+ "Add DIR to compiler.project_path, and to GPR_PROJECT_PATH in
project.environment."
+ ;; We maintain two project values for this;
+ ;; project-path - a list of directories, for elisp find file
+ ;; GPR_PROJECT_PATH in environment, for gnat-run
+ (let ((process-environment (copy-sequence (wisi-prj-file-env project)))
+ (compiler (wisi-prj-compiler project)))
+ (cl-pushnew dir (gnat-compiler-project-path compiler) :test #'string-equal)
+
+ (setenv "GPR_PROJECT_PATH"
+ (mapconcat 'identity
+ (gnat-compiler-project-path compiler) path-separator))
+ (setf (wisi-prj-file-env project) (copy-sequence process-environment))
))
-(defun ada-gnat-default-prj (prj)
- "For `ada-prj-default-list'."
- (gnat-prj-add-prj-dir default-directory prj))
-
-(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 (cl-copy-list (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
- (or
- (locate-file (substitute-in-file-name value)
(ada-prj-get 'prj_dir))
- (expand-file-name (substitute-in-file-name value)))))
- project)
- )))
+(defun gnat-get-paths (project)
+ "Add project and/or compiler source, project paths to PROJECT source-path
and project-path."
+ (let* ((compiler (wisi-prj-compiler project))
+ (src-dirs (wisi-prj-source-path project))
+ (prj-dirs (cl-copy-list (gnat-compiler-project-path compiler))))
-(defun gnat-prj-parse-emacs-final (project)
- "Final processing of gnat-specific Emacs Ada project file settings."
- ;; things may have changed, force re-create gnat or gpr-query sessions.
- (cl-ecase (ada-prj-get 'xref_tool project)
- (gnat
- (when (buffer-live-p (get-buffer (gnat-run-buffer-name)))
- (kill-buffer (gnat-run-buffer-name))))
-
- (gpr_query
- (let ((session (cdr (assoc ada-prj-current-file gpr-query--sessions))))
- (when session
- (gpr-query-kill-session session))))
- )
-
- (if (ada-prj-get 'gpr_file project)
- (setq 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-1 (src-dirs obj-dirs prj-dirs)
- "Append list of source, project and object dirs in current gpr project to
SRC-DIRS,
-OBJ-DIRS and PRJ-DIRS. Uses `gnat list'. Returns new (SRC-DIRS OBJ-DIRS
PRJ-DIRS)."
- (with-current-buffer (gnat-run-buffer)
- ;; gnat list -v -P can return status 0 or 4; always lists compiler dirs
+ ;; Don't need project plist obj_dirs if using a project file, so
+ ;; not setting obj-dirs.
;;
- ;; WORKAROUND: GNAT 7.2.1 gnatls does not support C++ fully; it
- ;; does not return src_dirs from C++ projects (see AdaCore ticket
- ;; M724-045). The workaround is to include the src_dirs in an
- ;; Emacs Ada mode project.
- (gnat-run-gnat "list" (list "-v") '(0 4))
+ ;; We only need to update prj-dirs if the gpr-file is an aggregate
+ ;; project that sets the project path.
+
+ (condition-case-unless-debug nil
+ (with-current-buffer (gnat-run-buffer project
(gnat-compiler-run-buffer-name (wisi-prj-compiler project)))
+ ;; gnat list -v -P can return status 0 or 4; always lists compiler
dirs
+ (gnat-run-gnat project "list" (list "-v") '(0 4))
- (goto-char (point-min))
+ (goto-char (point-min))
- (condition-case nil
- (progn
;; Source path
(search-forward "Source Search Path:")
(forward-line 1)
@@ -161,25 +127,10 @@ OBJ-DIRS and PRJ-DIRS. Uses `gnat list'. Returns new
(SRC-DIRS OBJ-DIRS PRJ-DIR
(directory-file-name
(buffer-substring-no-properties (point) (point-at-eol)))))
src-dirs
- :test #'equal)
- (forward-line 1))
-
- ;; Object path
- (search-forward "Object Search Path:")
- (forward-line 1)
- (while (not (looking-at "^$")) ; terminate on blank line
- (back-to-indentation) ; skip whitespace forward
- (cl-pushnew
- (if (looking-at "<Current_Directory>")
- (directory-file-name default-directory)
- (expand-file-name ; Canonicalize path part.
- (directory-file-name
- (buffer-substring-no-properties (point) (point-at-eol)))))
- obj-dirs
- :test #'equal)
+ :test #'string-equal)
(forward-line 1))
- ;; Project path
+ ;; Project path
;;
;; These are also added to src_dir, so compilation errors
;; reported in project files are found.
@@ -188,114 +139,87 @@ OBJ-DIRS and PRJ-DIRS. Uses `gnat list'. Returns new
(SRC-DIRS OBJ-DIRS PRJ-DIR
(while (not (looking-at "^$"))
(back-to-indentation)
(if (looking-at "<Current_Directory>")
- (cl-pushnew (directory-file-name default-directory) prj-dirs
:test #'equal)
- (let ((f (expand-file-name
+ (cl-pushnew (directory-file-name default-directory) prj-dirs
:test #'string-equal)
+ (let ((f (expand-file-name
(buffer-substring-no-properties (point)
(point-at-eol)))))
- (cl-pushnew f prj-dirs :test #'equal)
- (cl-pushnew f src-dirs :test #'equal)))
+ (cl-pushnew f prj-dirs :test #'string-equal)
+ (cl-pushnew f src-dirs :test #'string-equal)))
(forward-line 1))
)
(error
- (pop-to-buffer (current-buffer))
- ;; search-forward failed
- (error "parse gpr failed")
+ ;; search-forward failed. Possible causes:
+ ;;
+ ;; missing dirs in GPR_PROJECT_PATH => user error
+ ;; missing Object_Dir => gprbuild not run yet; it will be run soon
+ ;; some files are missing string quotes => user error
+ ;;
+ ;; We used to call gpr_query to get src-dirs, prj-dirs here; it
+ ;; is tolerant of the above errors. But ignoring the errors, to
+ ;; let gprbuild run with GPR_PROJECT_PATH set, is simpler.
+ (pop-to-buffer (gnat-run-buffer project (gnat-compiler-run-buffer-name
(wisi-prj-compiler project))))
+ (message "project search path: %s" prj-dirs)
+ (message "parse gpr failed")
))
- (list (cl-remove-duplicates src-dirs) (cl-remove-duplicates obj-dirs)
(cl-remove-duplicates prj-dirs))))
-;; IMPROVEME: use a dispatching function instead, with autoload, to
-;; avoid "require" here, and this declare
-;; Using 'require' at top level gives the wrong default ada-xref-tool
-(declare-function gpr-query-get-src-dirs "gpr-query.el" (src-dirs))
-(declare-function gpr-query-get-prj-dirs "gpr-query.el" (prj-dirs))
-(defun gnat-get-paths (project)
- "Add project and/or compiler source, object, project paths to PROJECT
src_dir, obj_dir and/or prj_dir."
- (let ((src-dirs (ada-prj-get 'src_dir project))
- (obj-dirs (ada-prj-get 'obj_dir project))
- (prj-dirs (ada-prj-get 'prj_dir project)))
-
- (cl-ecase (ada-prj-get 'xref_tool project)
- (gnat
- (let ((res (gnat-get-paths-1 src-dirs obj-dirs prj-dirs)))
- (setq src-dirs (pop res))
- (setq obj-dirs (pop res))
- (setq prj-dirs (pop res))))
-
- (gpr_query
- (when (ada-prj-get 'gpr_file)
- (require 'gpr-query)
- (setq src-dirs (gpr-query-get-src-dirs src-dirs))
- (setq obj-dirs nil) ;; gpr-query does not provide obj-dirs
- (setq prj-dirs (gpr-query-get-prj-dirs prj-dirs))))
- )
-
- (setq project (plist-put project 'src_dir (reverse src-dirs)))
- (setq project (plist-put project 'obj_dir (reverse obj-dirs)))
- (mapc (lambda (dir) (gnat-prj-add-prj-dir dir project))
- (reverse prj-dirs))
- )
- project)
+ ;; reverse prj-dirs so project file dirs precede gnat library dirs
+ (setf (wisi-prj-source-path project) (nreverse (delete-dups src-dirs)))
+ (setf (gnat-compiler-project-path compiler) nil)
+ (mapc (lambda (dir) (gnat-prj-add-prj-dir project dir))
+ prj-dirs)
+ ))
(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."
+ "Append to source-path and project-path in PROJECT (a `wisi-prj' object) by
parsing GPR-FILE.
+GPR-FILE must be absolute file name.
+source-path 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))
- )
-
- (condition-case-unless-debug nil
- ;; Can fail due to gpr_query not installed, or bad gpr file
- ;; syntax; allow .prj file settings to still work.
- (setq project (gnat-get-paths project))
- (message "Parsing %s ... done" gpr-file)
- (error
- (message "Parsing %s ... error" gpr-file))
- )
-
- project)
+ (let ((compiler (wisi-prj-compiler project)))
+ (if (gnat-compiler-gpr-file compiler)
+ ;; gpr-file previously set; new one must match
+ (when (not (string-equal gpr-file (gnat-compiler-gpr-file compiler)))
+ (error "project file %s defines a different GNAT project file than %s"
+ (gnat-compiler-gpr-file compiler)
+ gpr-file))
+
+ (setf (gnat-compiler-gpr-file compiler) gpr-file)
+ ))
+
+ (gnat-get-paths project))
+
+(defun gnat-parse-gpr-1 (gpr-file project)
+ "For `wisi-prj-parser-alist'."
+ (setf (gnat-compiler-run-buffer-name (wisi-prj-compiler project)) gpr-file)
+ (gnat-parse-gpr gpr-file project))
;;;; command line tool interface
-(defun gnat-run-buffer-name (&optional prefix)
+(defun gnat-run-buffer-name (prj-file-name &optional prefix)
+ ;; We don't use (gnat-compiler-gpr-file compiler), because multiple
+ ;; wisi-prj files can use one gpr-file.
(concat (or prefix " *gnat-run-")
- (or (ada-prj-get 'gpr_file)
- ada-prj-current-file)
+ prj-file-name
"*"))
-(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
+(defun gnat-run-buffer (project name)
+ "Return a buffer suitable for running gnat command line tools for PROJECT"
+ (let* ((buffer (get-buffer name)))
+
+ (unless (buffer-live-p 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 ada-gnat-show-run-buffer ()
- (interactive)
- (pop-to-buffer (gnat-run-buffer)))
-
-(defun gnat-run (exec command &optional err-msg expected-status)
+ (when (gnat-compiler-gpr-file (wisi-prj-compiler project))
+ ;; Otherwise assume `default-directory' is already correct (or
+ ;; doesn't matter).
+ (with-current-buffer buffer
+ (setq default-directory
+ (file-name-directory
+ (gnat-compiler-gpr-file (wisi-prj-compiler project)))))
+ ))
+ buffer))
+
+(defun gnat-run (project exec command &optional err-msg expected-status)
"Run a gnat command line tool, as \"EXEC COMMAND\".
+PROJECT is a `wisi-prj' object.
EXEC must be an executable found on `exec-path'.
COMMAND must be a list of strings.
ERR-MSG must be nil or a string.
@@ -309,7 +233,11 @@ Assumes current buffer is (gnat-run-buffer)"
(setq command (cl-delete-if 'null command))
- (let ((process-environment (cl-copy-list (ada-prj-get 'proc_env))) ;; for
GPR_PROJECT_PATH
+ (let ((process-environment
+ (append
+ (wisi-prj-compile-env project)
+ (wisi-prj-file-env project)
+ (copy-sequence process-environment)))
status)
(when ada-gnat-debug-run
@@ -330,25 +258,27 @@ Assumes current buffer is (gnat-run-buffer)"
))
)))
-(defun gnat-run-gnat (command &optional switches-args expected-status)
+(defun gnat-run-gnat (project 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)))))
- (target-gnat (concat (ada-prj-get 'target) "gnat"))
+ (let* ((compiler (wisi-prj-compiler project))
+ (gpr-file (gnat-compiler-gpr-file compiler))
+ (project-file-switch
+ (when gpr-file
+ (concat "-P" (file-name-nondirectory gpr-file))))
+ (target-gnat (concat (gnat-compiler-target compiler) "gnat"))
;; gnat list understands --RTS without a fully qualified
;; path, gnat find (in particular) doesn't (but it doesn't
;; need to, it uses the ALI files found via the GPR)
(runtime
- (when (and (ada-prj-get 'runtime) (string= command "list"))
- (list (concat "--RTS=" (ada-prj-get 'runtime)))))
+ (when (and (gnat-compiler-runtime compiler) (string= command "list"))
+ (list (concat "--RTS=" (gnat-compiler-runtime compiler)))))
(cmd (append (list command) (list project-file-switch) runtime
switches-args)))
- (gnat-run target-gnat cmd nil expected-status)
+ (gnat-run project target-gnat cmd nil expected-status)
))
(defun gnat-run-no-prj (command &optional dir)
@@ -376,6 +306,78 @@ which is displayed on error."
(error "gnat %s failed" (car command)))
)))
+(cl-defmethod wisi-compiler-parse-one ((compiler gnat-compiler) project name
value)
+ (cond
+ ((or
+ (string= name "ada_project_path") ;; backward compatibility
+ (string= name "gpr_project_path"))
+ (let ((process-environment
+ (append
+ (wisi-prj-compile-env project)
+ (wisi-prj-file-env project))));; reference, for
substitute-in-file-name
+ (gnat-prj-add-prj-dir project (expand-file-name (substitute-in-file-name
value)))))
+
+ ((string= name "gnat-stub-cargs")
+ (setf (gnat-compiler-gnat-stub-cargs compiler) value))
+
+ ((string= name "gnat-stub-opts")
+ (setf (gnat-compiler-gnat-stub-opts compiler) value))
+
+ ((string= name "gpr_file")
+ ;; The gpr file is parsed in `wisi-compiler-parse-final', so it
+ ;; sees all file environment vars. We store the absolute gpr
+ ;; file name, so we can get the correct default-directory from
+ ;; it. Note that gprbuild requires the base name be found on
+ ;; GPR_PROJECT_PATH.
+ (let ((process-environment
+ (append
+ (wisi-prj-compile-env project)
+ (wisi-prj-file-env project))));; reference, for
substitute-in-file-name
+ (setf (gnat-compiler-gpr-file compiler)
+ (or
+ (locate-file (substitute-in-file-name value)
+ (gnat-compiler-project-path compiler))
+ (expand-file-name (substitute-in-file-name value)))))
+ t)
+
+ ((string= name "runtime")
+ (setf (gnat-compiler-runtime compiler) value))
+
+ ((string= name "target")
+ (setf (gnat-compiler-target compiler) value))
+
+ ))
+
+(cl-defmethod wisi-compiler-parse-final ((compiler gnat-compiler) project
prj-file-name)
+ (setf (gnat-compiler-run-buffer-name compiler) (gnat-run-buffer-name
prj-file-name))
+
+ (if (gnat-compiler-gpr-file compiler)
+ (gnat-parse-gpr (gnat-compiler-gpr-file compiler) project)
+
+ ;; add the compiler libraries to project.source-path
+ (gnat-get-paths project)
+ ))
+
+(cl-defmethod wisi-compiler-select-prj ((_compiler gnat-compiler) _project)
+ (add-to-list 'completion-ignored-extensions ".ali") ;; gnat library files
+ (setq compilation-error-regexp-alist '(gnat))
+ )
+
+(cl-defmethod wisi-compiler-deselect-prj ((_compiler gnat-compiler) _project)
+ (setq completion-ignored-extensions (delete ".ali"
completion-ignored-extensions))
+ (setq compilation-error-regexp-alist (mapcar #'car
compilation-error-regexp-alist-alist))
+ )
+
+(cl-defmethod wisi-compiler-show-prj-path ((compiler gnat-compiler))
+ (if (gnat-compiler-project-path compiler)
+ (progn
+ (pop-to-buffer (get-buffer-create "*project file search path*"))
+ (erase-buffer)
+ (dolist (file (gnat-compiler-project-path compiler))
+ (insert (format "%s\n" file))))
+ (message "no project file search path set")
+ ))
+
;;;; gnatprep utils
(defun gnatprep-indent ()
@@ -406,134 +408,44 @@ list."
)
)))
+(defconst gnatprep-preprocessor-keywords
+ (list (list "^[ \t]*\\(#.*\n\\)" '(1 font-lock-preprocessor-face t))))
+
+;; We assume that if this file is loaded, any ada-mode buffer may have
+;; gnatprep syntax; even with different host/target compilers, both
+;; must run gnatprep first. If support for another preprocessor is
+;; added, we'll need wisi-prj-preprocessor, along with -compiler and
+;; -xref.
(defun gnatprep-setup ()
- (when (boundp 'wisi-indent-calculate-functions)
- (add-to-list 'wisi-indent-calculate-functions 'gnatprep-indent))
+ (add-to-list 'wisi-indent-calculate-functions 'gnatprep-indent)
+ (add-hook 'ada-syntax-propertize-hook #'gnatprep-syntax-propertize)
+ (font-lock-add-keywords 'ada-mode gnatprep-preprocessor-keywords)
+ ;; ada-mode calls font-lock-refresh-defaults after ada-mode-hook
)
-;;;; support for xref tools
-(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))
- (when ada-gnat-debug-run (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-chahan" . "Ada.Characters.Handling")
- ("a-comlin" . "Ada.Command_Line")
- ("a-contai" . "Ada.Containers")
- ("a-direct" . "Ada.Directories")
- ("a-except" . "Ada.Exceptions")
- ("a-ioexce" . "Ada.IO_Exceptions")
- ("a-finali" . "Ada.Finalization")
- ("a-numeri" . "Ada.Numerics")
- ("a-nuflra" . "Ada.Numerics.Float_Random")
- ("a-stream" . "Ada.Streams")
- ("a-ststio" . "Ada.Streams.Stream_IO")
- ("a-string" . "Ada.Strings")
- ("a-strmap" . "Ada.Strings.Maps")
- ("a-strunb" . "Ada.Strings.Unbounded")
- ("a-stwiun" . "Ada.Strings.Wide_Unbounded")
- ("a-textio" . "Ada.Text_IO")
- ("g-comlin" . "GNAT.Command_Line")
- ("g-dirope" . "GNAT.Directory_Operations")
- ("g-socket" . "GNAT.Sockets")
- ("i-c" . "Interfaces.C")
- ("i-cstrin" . "Interfaces.C.Strings")
- ("interfac" . "Interfaces")
- ("s-stoele" . "System.Storage_Elements")
- )
- "Alist (filename . package name) of GNAT file names for predefined Ada
packages.")
-
-(defun ada-gnat-ada-name-from-file-name (file-name)
- "For `ada-ada-name-from-file-name'."
- (let* ((ada-name (file-name-sans-extension (file-name-nondirectory
file-name)))
- (predefined (cdr (assoc ada-name ada-gnat-predefined-package-alist))))
-
- (if predefined
- predefined
- (while (string-match "-" ada-name)
- (setq ada-name (replace-match "." t t ada-name)))
- ada-name)))
-
-(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))
- (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))))
- (process-environment (cl-copy-list (ada-prj-get 'proc_env))) ;; for
GPR_PROJECT_PATH
- )
-
- ;; Make sure all relevant files are saved to disk.
- (save-some-buffers t)
- (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))
-
-(defun ada-gnat-syntax-propertize (start end)
- (goto-char start)
- (save-match-data
- (while (re-search-forward
- (concat
- "[^a-zA-Z0-9)]\\('\\)\\[[\"a-fA-F0-9]+\"\\]\\('\\)"; 1, 2:
non-ascii character literal, not attributes
- "\\|\\(\\[\"[a-fA-F0-9]+\"\\]\\)"; 3: non-ascii character in
identifier
- )
- end t)
- (cond
- ((match-beginning 1)
- (put-text-property
- (match-beginning 1) (match-end 1) 'syntax-table '(7 . ?'))
- (put-text-property
- (match-beginning 2) (match-end 2) 'syntax-table '(7 . ?')))
-
- ((match-beginning 3)
- (put-text-property
- (match-beginning 3) (match-end 3) 'syntax-table '(2 . nil)))
- )
- )))
-
-;;; setup
-(add-to-list 'ada-prj-default-list 'ada-gnat-default-prj)
+(add-hook 'ada-mode-hook #'gnatprep-setup)
+
+;;;; Initialization
+
+;; These are shared between ada-compiler-gnat and gpr-query.
+(add-to-list 'wisi-prj-file-extensions "gpr")
+(add-to-list 'wisi-prj-parser-alist '("gpr" . gnat-parse-gpr-1))
+
+(add-to-list
+ 'compilation-error-regexp-alist-alist
+ '(gnat
+ ;; typical:
+ ;; cards_package.adb:45:32: expected private type "System.Address"
+ ;;
+ ;; with full path Source_Reference pragma :
+ ;; d:/maphds/version_x/1773/sbs-abi-dll_lib.ads.gp:39:06: file
"interfaces_c.ads" not found
+ ;;
+ ;; gnu cc1: (gnatmake can invoke the C compiler)
+ ;; foo.c:2: `TRUE' undeclared here (not in a function)
+ ;; foo.c:2 : `TRUE' undeclared here (not in a function)
+ ;;
+ ;; we can't handle secondary errors here, because a regexp can't
distinquish "message" from "filename"
+ "^\\(\\(.:\\)?[^ :\n]+\\):\\([0-9]+\\)\\s-?:?\\([0-9]+\\)?" 1 3 4))
(provide 'gnat-core)
-
;; end of file
diff --git a/packages/ada-mode/gpr-indent-user-options.el
b/packages/ada-mode/gpr-indent-user-options.el
index cd17ee5..174a5eb 100644
--- a/packages/ada-mode/gpr-indent-user-options.el
+++ b/packages/ada-mode/gpr-indent-user-options.el
@@ -1,6 +1,6 @@
;; user options shared by gpr mode indentation engines -*- lexical-binding:t
-*-
;;
-;; Copyright (C) 2017 Free Software Foundation, Inc.
+;; Copyright (C) 2017, 2019 Free Software Foundation, Inc.
;;
;; Author: Stephen Leake <address@hidden>
;;
@@ -22,7 +22,7 @@
;;;; code
(defgroup gpr-indentation nil
- "Indentation options for Ada source."
+ "Indentation options for gpr source."
:group 'gpr)
(defcustom gpr-indent 3
@@ -35,13 +35,13 @@
"Indentation for the continuation of a broken line."
:type 'integer
:safe #'integerp)
-(make-variable-buffer-local 'ada-indent-broken)
+(make-variable-buffer-local 'gpr-indent-broken)
(defcustom gpr-indent-when 3
"Indentation for `when' relative to `case'."
:type 'integer
:safe #'integerp)
-(make-variable-buffer-local 'ada-indent-when)
+(make-variable-buffer-local 'gpr-indent-when)
(provide 'gpr-indent-user-options)
diff --git a/packages/ada-mode/gpr-mode.el b/packages/ada-mode/gpr-mode.el
index 0f0d698..bd524ad 100644
--- a/packages/ada-mode/gpr-mode.el
+++ b/packages/ada-mode/gpr-mode.el
@@ -34,39 +34,38 @@
;;
;;;;; Code:
-;; we reuse several ada-mode functions
-(require 'ada-mode)
(require 'cl-lib)
+(require 'gnat-core)
+(require 'gpr-indent-user-options)
+(require 'gpr-process)
+(require 'gpr-skel)
+(require 'wisi-process-parse)
+(require 'wisi-prj)
(defgroup gpr nil
"Major mode for editing gpr (Gnat Project File) source code in Emacs."
:group 'languages)
-(defcustom gpr-process-parse-exec "gpr_mode_wisi_parse.exe"
- "Name of executable to use for external process gpr parser,"
- :type 'string
- :group 'gpr)
-
(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 [return] 'wisi-indent-newline-indent)
;; comment-dwim is in global map on M-;
- (define-key map "\C-c\C-c" 'ada-build-make)
- (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)
- (define-key map "\C-c\C-o" 'ff-find-other-file)
+ (define-key map "\C-c\C-e" 'wisi-skel-expand)
+ (define-key map "\C-c\C-f" 'wisi-show-parse-error)
+ (define-key map "\C-c\C-i" 'wisi-indent-statement)
+ (define-key map "\C-c\C-o" 'ff-find-other-file)
(define-key map "\C-c\C-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" 'ada-case-create-partial-exception)
- (define-key map "\M-n" 'skeleton-next-placeholder)
- (define-key map "\M-p" 'skeleton-prev-placeholder)
+ (define-key map "\C-c\C-w" 'wisi-case-adjust-at-point)
+ (define-key map "\C-c\C-y" 'wisi-case-create-exception)
+ (define-key map "\C-c\C-\M-y" 'wisi-case-create-partial-exception)
+ (define-key map "\M-n" 'wisi-skel-next-placeholder)
+ (define-key map "\M-p" 'wisi-skel-prev-placeholder)
+
+ (wisi-case-activate-keys map)
+
map
) "Local keymap used for GPR mode.")
@@ -80,64 +79,25 @@
["Key bindings" describe-bindings t]
)
- ["Customize" (customize-group 'ada)];; we reuse the Ada indentation
options
+ ["Customize" (customize-group 'gpr)]
["------" nil nil]
- ["Build current project" ada-build-make t]
- ["Find and select project ..." ada-build-prompt-select-prj-file t]
- ["Select project ..." ada-prj-select t]
- ["Parse and select current file" gpr-set-as-project t]
- ["Show current project" ada-prj-show t]
- ["Show project search path" ada-prj-show-prj-path t]
+ ["Show current project" wisi-prj-show t]
+ ["Show project search path" wisi-prj-show-prj-path t]
["Next compilation error" next-error t]
- ["Show secondary error" ada-show-secondary-error t]
- ["Show last parse error" gpr-show-parse-error t]
+ ["Show last parse error" wisi-show-parse-error t]
["Other file" ff-find-other-file t]
("Edit"
["Indent Line or selection" indent-for-tab-command t]
- ["Indent current statement" gpr-indent-statement t]
+ ["Indent current statement" wisi-indent-statement t]
["Indent Lines in File" (indent-region (point-min) (point-max))
t]
- ["Expand skeleton" gpr-expand t]
- ["Next skeleton placeholder" skeleton-next-placeholder t]
- ["Previous skeleton placeholder" skeleton-prev-placeholder t]
+ ["Expand skeleton" wisi-skel-expand t]
+ ["Next skeleton placeholder" wisi-skel-next-placeholder t]
+ ["Previous skeleton placeholder" wisi-skel-prev-placeholder t]
["Comment/uncomment selection" comment-dwim 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)))
-
(defconst gpr-keywords
'(
"abstract"
@@ -156,7 +116,7 @@ Function is called with no arguments.")
"null"
"others"
"package"
- "project"
+ ;; "project" may also be a non-keyword attribute prefix; see
test/gpr/gds.gpr
"renames"
"standard"
"type"
@@ -174,7 +134,6 @@ Function is called with no arguments.")
"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"
;;
@@ -200,15 +159,57 @@ Function is called with no arguments.")
'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)))
+ "Return the name of the package or project point is in or just after, or
nil."
+ (wisi-validate-cache (point-min) (point) nil 'navigate)
+ ;; No message on parse fail, since this could be called from
which-function-mode
+ (when (wisi-cache-covers-pos 'navigate (point))
+ (let ((cache (wisi-backward-cache))
+ done
+ project-pos
+ package-pos
+ decl-pos)
+ (while (and cache (not done))
+ ;; find attribute_declaration and package containing point (if any)
+ (cond
+ ((not (eq (wisi-cache-class cache) 'statement-start))
+ nil)
+
+ ((eq (wisi-cache-nonterm cache) 'attribute_declaration)
+ (setq decl-pos (point)))
+
+ ((eq (wisi-cache-nonterm cache) 'package_spec)
+ (setq package-pos (point))
+ (setq done t))
+
+ ((eq (wisi-cache-nonterm cache) 'simple_project_declaration)
+ (setq project-pos (point))
+ (setq done t))
+ )
+
+ (setq cache (wisi-goto-containing cache)))
+
+ (cond
+ (package-pos
+ (goto-char package-pos)
+ (setq done t))
+
+ (decl-pos
+ (goto-char decl-pos)
+ (setq done t))
+
+ (project-pos
+ (goto-char project-pos)
+ (setq done t))
+
+ (t ;; before project
+ (setq done nil))
+ )
+
+ (when done
+ (wisi-next-name))
+
+ )))
(defun gpr-add-log-current-function ()
"For `add-log-current-defun-function'. Returns enclosing package or project
name."
@@ -220,19 +221,6 @@ of the package or project point is in or just after, or
nil.")
(end-of-line 1)
(gpr-which-function)))
-(declare-function gpr-query-kill-all-sessions "gpr-query.el" nil)
-(defun gpr-set-as-project (&optional file)
- "Set FILE (default current buffer file) as Emacs project file."
- (interactive)
- (save-some-buffers t)
- ;; Kill sessions to catch changed env vars
- (cl-ecase ada-xref-tool
- (gnat nil)
- (gpr_query (gpr-query-kill-all-sessions))
- )
- (ada-parse-prj-file (or file (buffer-file-name)))
- (ada-select-prj-file (or file (buffer-file-name))))
-
(defvar gpr-mode-syntax-table
(let ((table (make-syntax-table)))
;; (info "(elisp)Syntax Class Table" "*info syntax class table*")
@@ -247,13 +235,14 @@ of the package or project point is in or just after, or
nil.")
(modify-syntax-entry ?\" "\"" table)
;; punctuation; operators etc
+ (modify-syntax-entry ?- ". 124" table); operator, double hyphen as comment
(modify-syntax-entry ?& "." table)
(modify-syntax-entry ?. "." table)
(modify-syntax-entry ?: "." table)
(modify-syntax-entry ?= "." table)
(modify-syntax-entry ?> "." table)
(modify-syntax-entry ?\; "." table)
- (modify-syntax-entry ?\\ "." table); default is escape; not correct for
Ada strings
+ (modify-syntax-entry ?\\ "." table); default is escape; not correct for
gpr strings
(modify-syntax-entry ?\| "." table)
;; and \f and \n end a comment
@@ -265,7 +254,7 @@ of the package or project point is in or just after, or
nil.")
(modify-syntax-entry ?\( "()" table)
(modify-syntax-entry ?\) ")(" table)
- ;; skeleton placeholder delimiters; see ada-skel.el. We use generic
+ ;; skeleton placeholder delimiters; see gpr-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)
@@ -275,21 +264,98 @@ of the package or project point is in or just after, or
nil.")
)
"Syntax table to be used for editing gpr source code.")
-(defun gpr-syntax-propertize (start end)
- "Assign `syntax-table' properties in accessible part of buffer."
- ;; (info "(elisp)Syntax Properties")
- ;;
- ;; called from `syntax-propertize', inside save-excursion
with-silent-modifications
- ;; syntax-propertize-extend-region-functions is set to
- ;; syntax-propertize-wholelines by default.
- (let ((inhibit-read-only t)
- (inhibit-point-motion-hooks t))
- (goto-char start)
- (save-match-data
- (while (re-search-forward "--" end t); comment start
- (put-text-property
- (match-beginning 0) (match-end 0) 'syntax-table '(11 . nil)))
- )))
+;;;; wisi integration
+
+(defcustom gpr-auto-case t
+ "When non-nil, automatically change case of preceding word while
+typing. Casing of gpr keywords is done according to `gpr-case-keyword',
+identifiers according to `gpr-case-identifier'."
+ :group 'gpr
+ :type '(choice (const nil)
+ (const t))
+ :safe (lambda (val) (memq val '(nil t))))
+(make-variable-buffer-local 'gpr-auto-case)
+
+(defcustom gpr-case-keyword 'lower-case
+ "Indicate how to adjust case for language keywords.
+Value is one of lower-case, upper-case."
+ :group 'gpr
+ :type '(choice (const lower-case)
+ (const upper-case))
+ :safe #'symbolp)
+(make-variable-buffer-local 'gpr-case-keyword)
+
+(defcustom gpr-case-strict t
+ "If non-nil, force Mixed_Case for identifiers.
+Otherwise, allow UPPERCASE for identifiers."
+ :group 'gpr
+ :type 'boolean
+ :safe #'booleanp)
+(make-variable-buffer-local 'gpr-case-strict)
+
+(defcustom gpr-case-identifier 'mixed-case
+ "Indicates how to adjust the case of gpr keywords."
+ :group 'gpr
+ :type '(choice (const mixed-case)
+ (const lower-case)
+ (const upper-case))
+ ;; see comment on :safe at gpr-case-keyword
+ :safe (lambda (val) (memq val '(mixed-case lower-case upper-case))))
+(make-variable-buffer-local 'gpr-case-identifier)
+
+(defun gpr-case-adjust-p (_typed-char)
+ "For `wisi-case-adjust-p-function'."
+ ;; casing of 'project' in "Project'Project_Dir" vs "project GDS is"
+ (save-excursion
+ (let ((end (1+ (point)))
+ (start (progn (skip-syntax-backward "w")(point))))
+ (cond
+ ((string= "project" (downcase (buffer-substring-no-properties start
end)))
+ (cond
+ ((= (char-after end) ?') ;; attribute Project'
+ t)
+ ((= (char-after end) ? ) ;; keyword project GDS
+ (wisi-case-keyword start end)
+ nil)
+ ))
+
+ (t t) ;; not "project"
+ ))))
+
+(cl-defstruct (gpr-wisi-parser (:include wisi-process--parser))
+ ;; no new slots
+ )
+
+(cl-defstruct (gpr-prj (:include wisi-prj))
+ ;; no new slots
+ )
+
+(defun gpr-prj-default (&optional name)
+ (make-gpr-prj :name (or name "_default_") :compiler (make-gnat-compiler)))
+
+(cl-defmethod wisi-prj-default ((prj gpr-prj))
+ (gpr-prj-default (wisi-prj-name prj)))
+
+(cl-defmethod wisi-parse-format-language-options ((_parser gpr-wisi-parser))
+ (format "%d %d %d"
+ gpr-indent
+ gpr-indent-broken
+ gpr-indent-when
+ ))
+
+(defconst gpr-wisi-language-protocol-version "1"
+ "Defines language-specific parser parameters.
+Must match wisi-gpr.ads Language_Protocol_Version.")
+
+(defcustom gpr-process-parse-exec "gpr_mode_wisi_parse.exe"
+ "Name of executable to use for external process gpr parser,"
+ :type 'string
+ :group 'gpr)
+
+(defun gpr-set-as-project ()
+ "Set current buffer (a gpr file) as current project file."
+ (interactive)
+ (wisi-prj-dtrt-parse-file (buffer-file-name) (gpr-prj-default
(buffer-file-name)) (buffer-file-name)))
;;;;
;;;###autoload
@@ -302,10 +368,6 @@ of the package or project point is in or just after, or
nil.")
(setq mode-name "GNAT Project")
(use-local-map gpr-mode-map)
(set-syntax-table gpr-mode-syntax-table)
- (set (make-local-variable 'syntax-propertize-function)
'gpr-syntax-propertize)
- (when (boundp 'syntax-begin-function)
- ;; obsolete in emacs-25.1
- (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) "")
@@ -314,9 +376,6 @@ of the package or project point is in or just after, or
nil.")
(set (make-local-variable 'require-final-newline) t)
- (ada-case-activate-keys gpr-mode-map)
- (set (make-local-variable 'ada-keywords) gpr-keywords)
-
(set (make-local-variable 'font-lock-defaults)
'(gpr-font-lock-keywords
nil t
@@ -328,8 +387,28 @@ of the package or project point is in or just after, or
nil.")
(set (make-local-variable 'add-log-current-defun-function)
'gpr-add-log-current-function)
+ (wisi-setup
+ :indent-calculate nil
+ :post-indent-fail nil
+ :parser
+ (wisi-process-parse-get
+ (make-gpr-wisi-parser
+ :label "gpr"
+ :language-protocol-version gpr-wisi-language-protocol-version
+ :exec-file gpr-process-parse-exec
+ :face-table gpr-process-face-table
+ :token-table gpr-process-token-table
+ :repair-image gpr-process-repair-image
+ )))
+
(run-mode-hooks 'gpr-mode-hook)
+ (setq wisi-auto-case gpr-auto-case)
+ (setq wisi-case-identifier gpr-case-identifier)
+ (setq wisi-case-strict gpr-case-strict)
+ (setq wisi-language-keywords gpr-keywords)
+ (setq wisi-case-keyword gpr-case-keyword)
+ (setq wisi-case-adjust-p-function #'gpr-case-adjust-p)
)
;;;###autoload
@@ -337,29 +416,12 @@ of the package or project point is in or just after, or
nil.")
(put 'gpr-mode 'custom-mode-group 'gpr)
-(defvar gpr-parser nil
+(defvar gpr-parser 'process
"Indicate parser and lexer to use for gpr buffers:
-elisp : wisi parser and lexer implemented in elisp.
-
process : wisi elisp lexer, external process parser specified
by ‘gpr-process-parse-exec ’.
")
(provide 'gpr-mode)
-
-(require 'gpr-wisi)
-
-(cl-case gpr-parser
- (elisp nil)
- (process nil)
- (t
- (if (locate-file gpr-process-parse-exec exec-path '("" ".exe"))
- (setq gpr-parser 'process)
- (setq gpr-parser 'elisp)))
- )
-
-(unless (featurep 'gpr-skeletons)
- (require 'gpr-skel))
-
-;;; end of file
+;;; gpr-mode.el ends here
diff --git a/packages/ada-mode/gpr-mode.info b/packages/ada-mode/gpr-mode.info
index 3bba3a6..816c661 100644
--- a/packages/ada-mode/gpr-mode.info
+++ b/packages/ada-mode/gpr-mode.info
@@ -62,14 +62,6 @@ gpr mode is distributed in the Gnu ELPA package archive,
bundled with
Ada mode; it can be installed via 'M-x list-packages' (*note
(emacs)Packages::).
- gpr mode is also available as a separate distribution bundled with
-Ada mode, from the Emacs Ada mode website
-<http://stephe-leake.org/emacs/ada-mode/emacs-ada-mode.html>. The
-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'.
@@ -80,9 +72,9 @@ File: gpr-mode.info, Node: Customization, Next: Moving
Through Gpr Code, Prev
3 Customization
***************
-gpr mode uses the Ada mode indentation variables; they can be set via
-the menu 'Ada | Customize' from an Ada mode buffer. Click on the 'Help'
-button there for help on using customize.
+Indentation variables for gpr mode can be set via the menu 'gpr |
+Customize' from a gpr mode buffer. Click on the 'Help' button there for
+help on using customize. *Note Indentation::.
To modify a specific variable, you can directly call the function
'customize-variable'; just type 'M-x customize-variable <RET>
@@ -104,14 +96,14 @@ the syntax to set a variable is the following:
Bind 'hippie-expand' to a key; it expands the word before point,
using words from current buffer, other buffers, file names, etc;
see 'hippie-expand-try-functions-list'. You can also add
- 'skeleton-hippie-try' to that list (*note Statement skeletons::).
+ 'wisi-skel-hippie-try' to that list (*note Statement skeletons::).
The above can all be set by the following code in your '~/.emacs'.
Note that some are functions are added to 'before-save-hook'; they run
just before a buffer is written to disk.
(setq-default indent-tabs-mode nil)
(require 'gpr-mode)
- (add-to-list 'hippie-expand-try-functions-list 'skeleton-hippie-try)
+ (add-to-list 'hippie-expand-try-functions-list 'wisi-skel-hippie-try)
(define-key gpr-mode-map "\C-e" 'hippie-expand)
(add-hook 'gpr-mode-hook
(lambda ()
@@ -136,6 +128,12 @@ available through the gpr menu and keybindings.
'C-u SPACE'
Jump back to the previous location.
+'C-M-f'
+ Move to the end of the current declaration.
+
+'C-M-b'
+ Move to the start of the current declaration.
+
File: gpr-mode.info, Node: Identifier completion, Next: Indentation, Prev:
Moving Through Gpr Code, Up: Top
@@ -147,6 +145,8 @@ Emacs provides a general way of completing identifiers:
'M-/' (bound to
type the first few letters of an identifier, and then loop through all
the possible completions.
+ If you have bound 'hippie-expand', that also uses 'dabbrev-expand'.
+
'M-/' works by parsing all open gpr files for possible completions.
For instance, if the words 'my_identifier' and 'my_subprogram' are
@@ -171,18 +171,14 @@ File: gpr-mode.info, Node: Indentation, Next: Statement
skeletons, Prev: Iden
gpr mode comes with a full set of rules for automatic indentation. You
can also configure the indentation, via the following variables:
-'ada-indent' (default value: 3)
+'gpr-indent' (default value: 3)
Number of columns for default indentation.
-'ada-indent-broken' (default value: 2)
+'gpr-indent-broken' (default value: 2)
Number of columns to indent the continuation of a broken line.
-'ada-indent-when' (default value: 3)
- Indentation for 'when' relative to 'exception', 'case', or 'or' in
- 'select'.
-
-'ada-indent-with' (default value: ada-indent-broken)
- Indentation for the lines in a 'with' context clause.
+'gpr-indent-when' (default value: 3)
+ Indentation for 'when' relative to 'case'.
The following keys indent portions of the text:
@@ -195,43 +191,9 @@ can also configure the indentation, via the following
variables:
'C-c TAB'
Indent the current declaration.
- The indentation algorithm relies on a grammar parser to identify the
-syntactic role for keywords and other words in the code. If the code is
-accepted by the parser, the indentation is done according to the rules
-in the indentation engine.
-
- If the code is not accepted (because it is partially complete during
-editing), the indentation engine falls back to the trivial algorithm of
-indenting each new line the same as the previous line. Once enough new
-text has been entered to make the code acceptable to the parser, the
-declaration is properly indented.
-
- For example, if you are entering this code:
-
- for Source_Dirs use
- ("../../1553/test",
- "../../system/test");
-
- when you type 'RET (', '(' is indented to the same column as 'for',
-because the parser does not find ');'. Then when you type the final ';'
-followed by <TAB>, all three lines are indented, putting '(' where it
-belongs.
-
- To be more user friendly, the parser accepts a superset of the gpr
-grammer. For example, the parser accepts this code for a 'case'
-statement:
-
- case is
- end case;
-
- 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::.
-
- In rare cases, the parser gets confused; it can be reset by invoking
-menu <gpr | Misc | Reset parser>. Please report such cases as a bug.
+ The indentation algorithm relies on an error-correcting grammar
+parser to identify the syntactic role for keywords and other words in
+the code.
File: gpr-mode.info, Node: Statement skeletons, Next: GNU Free Documentation
License, Prev: Indentation, Up: Top
@@ -246,9 +208,6 @@ skeleton. For example, 'c a s e C-c C-e' expands to:
when =>
end case;
- All skeleton expansions are accepted by the indentation parser, so
-this is a convenient way to insert statements with correct indentation.
-
For named packages, the name is taken from the word before point, and
the package keyword from the word before that:
@@ -762,12 +721,12 @@ Tag Table:
Node: Top952
Node: Overview1227
Node: Installation1786
-Node: Customization2537
-Node: Moving Through Gpr Code4459
-Node: Identifier completion4909
-Node: Indentation5871
-Node: Statement skeletons8201
-Node: GNU Free Documentation License8957
-Node: Index34119
+Node: Customization2226
+Node: Moving Through Gpr Code4151
+Node: Identifier completion4719
+Node: Indentation5753
+Node: Statement skeletons6656
+Node: GNU Free Documentation License7269
+Node: Index32431
End Tag Table
diff --git a/packages/ada-mode/gpr-mode.texi b/packages/ada-mode/gpr-mode.texi
index 796ccff..da6b27f 100644
--- a/packages/ada-mode/gpr-mode.texi
+++ b/packages/ada-mode/gpr-mode.texi
@@ -73,14 +73,6 @@ gpr mode is distributed in the Gnu ELPA package archive,
bundled with
Ada mode; it can be installed via @code{M-x list-packages}
(@pxref{Packages,,,emacs,Emacs User Guide}).
-gpr mode is also available as a separate distribution bundled with
-Ada mode, from the Emacs Ada mode website
-@uref{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 @file{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
@kbd{M-x ada-mode-version}.
@@ -88,9 +80,9 @@ version number. To see what version of Ada mode you have
installed, do
@node Customization, Moving Through Gpr Code, Installation, Top
@chapter Customization
-gpr mode uses the Ada mode indentation variables; they can be set via
-the menu @samp{Ada | Customize} from an Ada mode buffer. Click on the
-@samp{Help} button there for help on using customize.
+Indentation variables for gpr mode can be set via the menu @samp{gpr |
+Customize} from a gpr mode buffer. Click on the @samp{Help} button
+there for help on using customize. @xref{Indentation}.
To modify a specific variable, you can directly call the function
@code{customize-variable}; just type @kbd{M-x customize-variable
@@ -115,7 +107,7 @@ Don't insert tab characters when indenting.
Bind @code{hippie-expand} to a key; it expands the word before point,
using words from current buffer, other buffers, file names, etc; see
@code{hippie-expand-try-functions-list}. You can also add
-@code{skeleton-hippie-try} to that list (@pxref{Statement skeletons}).
+@code{wisi-skel-hippie-try} to that list (@pxref{Statement skeletons}).
@end table
The above can all be set by the following code in your
@@ -124,7 +116,7 @@ The above can all be set by the following code in your
@example
(setq-default indent-tabs-mode nil)
(require 'gpr-mode)
-(add-to-list 'hippie-expand-try-functions-list 'skeleton-hippie-try)
+(add-to-list 'hippie-expand-try-functions-list 'wisi-skel-hippie-try)
(define-key gpr-mode-map "\C-e" 'hippie-expand)
(add-hook 'gpr-mode-hook
(lambda ()
@@ -149,6 +141,12 @@ corresponding package declaration.
@item C-u SPACE
Jump back to the previous location.
+@item C-M-f
+Move to the end of the current declaration.
+
+@item C-M-b
+Move to the start of the current declaration.
+
@end table
@node Identifier completion, Indentation, Moving Through Gpr Code, Top
@@ -159,6 +157,9 @@ Emacs provides a general way of completing identifiers:
@kbd{M-/}
you just have to type the first few letters of an identifier, and then
loop through all the possible completions.
+If you have bound @code{hippie-expand}, that also uses
+@code{dabbrev-expand}.
+
@kbd{M-/} works by parsing all open gpr files for possible
completions.
@@ -184,18 +185,14 @@ gpr mode comes with a full set of rules for automatic
indentation. You
can also configure the indentation, via the following variables:
@table @asis
-@item @code{ada-indent} (default value: 3)
+@item @code{gpr-indent} (default value: 3)
Number of columns for default indentation.
-@item @code{ada-indent-broken} (default value: 2)
+@item @code{gpr-indent-broken} (default value: 2)
Number of columns to indent the continuation of a broken line.
-@item @code{ada-indent-when} (default value: 3)
-Indentation for @code{when} relative to @code{exception}, @code{case},
-or @code{or} in @code{select}.
-
-@item @code{ada-indent-with} (default value: ada-indent-broken)
-Indentation for the lines in a @code{with} context clause.
+@item @code{gpr-indent-when} (default value: 3)
+Indentation for @code{when} relative to @code{case}.
@end table
@@ -213,48 +210,9 @@ Indent the current declaration.
@end table
-The indentation algorithm relies on a grammar parser to identify the
-syntactic role for keywords and other words in the code. If the code
-is accepted by the parser, the indentation is done according to the
-rules in the indentation engine.
-
-If the code is not accepted (because it is partially complete during
-editing), the indentation engine falls back to the trivial algorithm
-of indenting each new line the same as the previous line. Once enough
-new text has been entered to make the code acceptable to the parser,
-the declaration is properly indented.
-
-For example, if you are entering this code:
-
-@example
- for Source_Dirs use
- ("../../1553/test",
- "../../system/test");
-@end example
-
-when you type @kbd{RET (}, @code{(} is indented to the same column as
-@code{for}, because the parser does not find @code{);}. Then when
-you type the final @code{;} followed by @key{TAB}, all three lines are
-indented, putting @code{(} where it belongs.
-
-To be more user friendly, the parser accepts a superset of the gpr
-grammer. For example, the parser accepts this code for a @code{case}
-statement:
-
-@example
-case is
-end case;
-@end example
-
-In general, any sequence of statements, and many expressions, may be
-omitted.
-
-One way to easily insert empty statements like this is using
-@ref{Statement skeletons}.
-
-In rare cases, the parser gets confused; it can be reset by invoking
-menu @key{gpr | Misc | Reset parser}. Please report such cases as a
-bug.
+The indentation algorithm relies on an error-correcting grammar parser
+to identify the syntactic role for keywords and other words in the
+code.
@node Statement skeletons, GNU Free Documentation License, Indentation, Top
@chapter Statement skeletons
@@ -268,10 +226,6 @@ when =>
end case;
@end example
-All skeleton expansions are accepted by the indentation parser, so
-this is a convenient way to insert statements with correct
-indentation.
-
For named packages, the name is taken from
the word before point, and the package keyword from the word
before that:
diff --git a/packages/ada-mode/gpr-process.el b/packages/ada-mode/gpr-process.el
index 0f3e210..54257a5 100644
--- a/packages/ada-mode/gpr-process.el
+++ b/packages/ada-mode/gpr-process.el
@@ -98,6 +98,7 @@
(defconst gpr-process-face-table
[
font-lock-function-name-face
+ font-lock-keyword-face
nil
])
diff --git a/packages/ada-mode/gpr-query.el b/packages/ada-mode/gpr-query.el
index 7047bf1..55d4827 100644
--- a/packages/ada-mode/gpr-query.el
+++ b/packages/ada-mode/gpr-query.el
@@ -1,707 +1,790 @@
-;; gpr-query.el --- Minor mode for navigating sources using gpr_query -*-
lexical-binding:t -*-
-;;
-;; gpr-query supports Ada and any gcc language that supports the
-;; AdaCore -fdump-xref switch (which includes C, C++).
-;;
-;; Copyright (C) 2013 - 2019 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 gpr-query
-
-(require 'ada-mode-compat) ;; font-lock-ensure
-
-(require 'ada-mode) ;; for ada-prj-*, some other things
-(require 'gnat-core)
-(require 'cl-lib)
-(require 'compile)
-
-(eval-and-compile
- (when (> emacs-major-version 24)
- (require 'xref)))
-
-;;;;; sessions
-
-;; gpr_query 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 gpr_query
-;; 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 (gpr-query--session)
- (process nil) ;; running gpr_query
- (buffer nil)) ;; receives output of gpr_query; default-directory gives
location of db
-
-;; Starting the buffer name with a space hides it from some lists, and
-;; also disables font-lock. We sometimes use it to display xref
-;; locations in compilation-mode, so we want font-lock enabled.
-;;
-;; IMPROVEME: copy the xref info to a true user buffer, optionally an
-;; *xref* buffer.
-(defconst gpr-query-buffer-name-prefix "*gpr_query-")
-
-(defun gpr-query--start-process (session)
- "Start the session process running gpr_query."
- (unless (buffer-live-p (gpr-query--session-buffer session))
- ;; user may have killed buffer
- (setf (gpr-query--session-buffer session) (gnat-run-buffer
gpr-query-buffer-name-prefix))
- (with-current-buffer (gpr-query--session-buffer session)
- (compilation-mode)
- (setq buffer-read-only nil)))
-
- (with-current-buffer (gpr-query--session-buffer session)
- (let ((process-environment (cl-copy-list (ada-prj-get 'proc_env)))
- ;; for GPR_PROJECT_PATH, other env vars set in ada-mode
- ;; project files and used by gpr files.
-
- (project-file (file-name-nondirectory (ada-prj-get 'gpr_file))))
-
- (erase-buffer); delete any previous messages, prompt
- (setf (gpr-query--session-process session)
- (start-process (concat "gpr_query " (buffer-name))
- (gpr-query--session-buffer session)
- "gpr_query"
- (concat "--project=" project-file)))
- (set-process-query-on-exit-flag (gpr-query--session-process session) nil)
- (gpr-query-session-wait session)
-
- ;; Check for warnings about invalid directories etc. But some
- ;; warnings are tolerable, so only abort if process actually
- ;; died.
- (if (process-live-p (gpr-query--session-process session))
- (progn
- (goto-char (point-min))
- (when (search-forward "warning:" nil t)
- (if debug-on-error
- (error "gpr_query warnings")
- (beep)
- (message "gpr_query warnings"))))
-
- (error "gpr-query process failed to start"))
- )))
-
-(defun gpr-query--make-session ()
- "Create and return a session for the current project file."
- (let ((session
- (make-gpr-query--session
- :buffer nil
- :process nil)))
- (gpr-query--start-process session)
- session))
-
-(defvar gpr-query--sessions '()
- "Assoc list of sessions, indexed by absolute GNAT project file name.")
-
-(defun gpr-query-cached-session ()
- "Return a session for the current project file, creating it if necessary."
- (let ((session (cdr (assoc ada-prj-current-file gpr-query--sessions))))
- (if session
- (progn
- (unless (process-live-p (gpr-query--session-process session))
- (gpr-query--start-process session))
- session)
- ;; else
- (prog1
- (setq session (gpr-query--make-session))
- (setq gpr-query--sessions
- (cl-acons ada-prj-current-file session gpr-query--sessions))))
- ))
-
-(defconst gpr-query-prompt "^>>> $"
- ;; gpr_query output ends with this
- "Regexp matching gpr_query prompt; indicates previous command is complete.")
-
-(defun gpr-query-session-wait (session)
- "Wait for the current command to complete."
- (unless (process-live-p (gpr-query--session-process session))
- (gpr-query-show-buffer session)
- (error "gpr-query process died"))
-
- (with-current-buffer (gpr-query--session-buffer session)
- (let ((process (gpr-query--session-process session))
- (search-start (point-min))
- (wait-count 0))
- (while (and (process-live-p process)
- (progn
- ;; process output is inserted before point, so move back
over it to search it
- (goto-char search-start)
- (not (re-search-forward gpr-query-prompt (point-max) 1))))
- (setq search-start (point));; don't search same text again
- (message (concat "running gpr_query ..." (make-string wait-count ?.)))
- ;; IMPROVEME: use --display-progress
- (accept-process-output process 1.0)
- (setq wait-count (1+ wait-count)))
- (if (process-live-p process)
- (message (concat "running gpr_query ... done"))
- (gpr-query-show-buffer session)
- (error "gpr_query process died"))
- )))
-
-(defun gpr-require-prj ()
- "Throw error if no project file defined."
- (unless (or (ada-prj-get 'gpr_file)
- (ada-prj-get 'gpr_query_file))
- (error "no gpr project file defined.")))
-
-(defun gpr-query-session-send (cmd wait)
- "Send CMD to gpr_query session for current project.
-If WAIT is non-nil, wait for command to complete.
-Return buffer that holds output."
- (gpr-require-prj)
- (let ((session (gpr-query-cached-session)))
- ;; always wait for previous command to complete; also checks for
- ;; dead process.
- (gpr-query-session-wait session)
- (with-current-buffer (gpr-query--session-buffer session)
- (erase-buffer)
- (process-send-string (gpr-query--session-process session)
- (concat cmd "\n"))
- (when wait
- (gpr-query-session-wait session))
- (current-buffer)
- )))
-
-(defun gpr-query-kill-session (session)
- (let ((process (gpr-query--session-process session)))
- (when (process-live-p process)
- (process-send-string (gpr-query--session-process session) "exit\n")
- (while (process-live-p process)
- (accept-process-output process 1.0)))
- ))
-
-(defun gpr-query-kill-all-sessions ()
- (interactive)
- (let ((count 0))
- (mapc (lambda (assoc)
- (let ((session (cdr assoc)))
- (when (process-live-p (gpr-query--session-process session))
- (setq count (1+ count))
- (process-send-string (gpr-query--session-process session)
"exit\n")
- )))
- gpr-query--sessions)
- (message "Killed %d sessions" count)
- ))
-
-(defun gpr-query-show-buffer (&optional session)
- "For `ada-show-xref-tool-buffer'; show gpr-query buffer for current project."
- (interactive)
- (pop-to-buffer (gpr-query--session-buffer (or session
(gpr-query-cached-session)))))
-
-;;;;; utils
-
-(defun gpr-query-get-src-dirs (src-dirs)
- "Append list of source dirs in current gpr project to SRC-DIRS.
-Uses `gpr_query'. Returns new list."
-
- (with-current-buffer (gpr-query--session-buffer (gpr-query-cached-session))
- (gpr-query-session-send "source_dirs" t)
- (goto-char (point-min))
- (while (not (looking-at gpr-query-prompt))
- (cl-pushnew
- (expand-file-name ; Canonicalize path part.
- (directory-file-name
- (buffer-substring-no-properties (point) (point-at-eol))))
- src-dirs :test #'equal)
- (forward-line 1))
- )
- src-dirs)
-
-(defun gpr-query-get-prj-dirs (prj-dirs)
- "Append list of project dirs in current gpr project to PRJ-DIRS.
-Uses `gpr_query'. Returns new list."
-
- (with-current-buffer (gpr-query--session-buffer (gpr-query-cached-session))
- (gpr-query-session-send "project_path" t)
- (goto-char (point-min))
- (while (not (looking-at gpr-query-prompt))
- (cl-pushnew
- (let ((dir (buffer-substring-no-properties (point) (point-at-eol))))
- (if (string= dir ".")
- (directory-file-name default-directory)
- (expand-file-name dir))) ; Canonicalize path part.
- prj-dirs
- :test #'equal)
- (forward-line 1))
- )
- prj-dirs)
-
-(defconst gpr-query-ident-file-regexp
- ;;
C:\Projects\GDS\work_dscovr_release\common\1553\gds-mil_std_1553-utf.ads:252:25
- ;;
/Projects/GDS/work_dscovr_release/common/1553/gds-mil_std_1553-utf.ads:252:25
- "\\(\\(?:.:\\\\\\|/\\)[^:]*\\):\\([0123456789]+\\):\\([0123456789]+\\)"
- ;; 1 2 3
- "Regexp matching <file>:<line>:<column>")
-
-(defconst gpr-query-ident-file-regexp-alist
- (list (concat "^" gpr-query-ident-file-regexp) 1 2 3)
- "For compilation-error-regexp-alist, matching gpr_query output")
-
-(defconst gpr-query-ident-file-type-regexp
- (concat gpr-query-ident-file-regexp " (\\(.*\\))")
- "Regexp matching <file>:<line>:<column> (<type>)")
-
-(defun gpr-query-compilation (identifier file line col cmd comp-err)
- "Run gpr_query IDENTIFIER:FILE:LINE:COL CMD,
-with compilation-error-regexp-alist set to COMP-ERR."
- ;; Useful when gpr_query will return a list of references; the user
- ;; can navigate to each result in turn via `next-error'.
- ;; FIXME: implement ada-xref-full-path.
- ;;
- ;; FIXME: implement append
-
- ;; Emacs column is 0-indexed, gpr_query is 1-indexed.
- (let ((cmd-1 (format "%s %s:%s:%d:%d" cmd identifier file line (1+ col)))
- (result-count 0)
- target-file target-line target-col)
- (with-current-buffer (gpr-query--session-buffer (gpr-query-cached-session))
- (setq buffer-read-only nil)
- (set (make-local-variable 'compilation-error-regexp-alist) (list
comp-err))
- (gpr-query-session-send cmd-1 t)
-
- ;; point is at EOB. gpr_query returns one line per result plus prompt,
warnings
- (setq result-count (- (line-number-at-pos) 1))
-
- (compilation--flush-parse (point-min) (point-max))
- (compilation--ensure-parse (point-max))
-
- (goto-char (point-min))
- (cond
- ((looking-at "^warning: ")
- (setq result-count (1- result-count))
- (forward-line 1))
- ((looking-at "^Error: entity not found")
- (error (buffer-substring-no-properties (line-beginning-position)
(line-end-position))))
- )
-
- (cl-case result-count
- (0
- (error "gpr_query returned no results"))
- (1
- ;; just go there, don't display session-buffer. We have to
- ;; fetch the compilation-message while in the
- ;; session-buffer. and call ada-goot-source outside the
- ;; with-current-buffer above.
- (let* ((msg (compilation-next-error 0))
- ;; IMPROVEME: '--' indicates internal-only. But we can't
- ;; use compile-goto-error, because that displays the
- ;; session-buffer.
- (loc (compilation--message->loc msg)))
- (setq target-file (caar (compilation--loc->file-struct loc))
- target-line (caar (cddr (compilation--loc->file-struct loc)))
- target-col (1- (compilation--loc->col loc))
- )
- ))
-
- (t
- ;; for next-error, below
- (setq next-error-last-buffer (current-buffer)))
-
- ));; case, with-currrent-buffer
-
- (if (= result-count 1)
- (ada-goto-source target-file target-line target-col)
-
- ;; more than one result; display session buffer, goto first ref
- ;;
- ;; compilation-next-error-function assumes there is not an error
- ;; at point-min; work around that by moving forward 0 errors for
- ;; the first one. Unless the first line contains "warning: ".
- (pop-to-buffer next-error-last-buffer)
- (goto-char (point-min))
- (if (looking-at "^warning: ")
- (next-error 1 t)
- (next-error 0 t))
- )
- ))
-
-(defun gpr-query-dist (found-line line found-col col)
- "Return distance between FOUND-LINE FOUND-COL and LINE COL."
- (+ (abs (- found-col col))
- (* (abs (- found-line line)) 250)))
-
-;;;;; user interface functions
-
-(defun gpr-query-show-references ()
- "Show all references of identifier at point."
- (interactive)
- (gpr-query-all
- (thing-at-point 'symbol)
- (file-name-nondirectory (buffer-file-name))
- (line-number-at-pos)
- (current-column))
- )
-
-(defun gpr-query-overridden ()
- "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
- (gpr-query-overridden-1
- (thing-at-point 'symbol)
- (buffer-file-name)
- (line-number-at-pos)
- (save-excursion
- (goto-char (car (bounds-of-thing-at-point 'symbol)))
- (current-column))
- )))
-
- (ada-goto-source (nth 0 target)
- (nth 1 target)
- (nth 2 target))
- ))
-
-(defun gpr-query-goto-declaration ()
- "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
- (gpr-query-other
- (thing-at-point 'symbol)
- (buffer-file-name)
- (line-number-at-pos)
- (save-excursion
- (goto-char (car (bounds-of-thing-at-point 'symbol)))
- (current-column))
- )))
-
- (ada-goto-source (nth 0 target)
- (nth 1 target)
- (nth 2 target))
- ))
-
-(defvar gpr-query-map
- (let ((map (make-sparse-keymap)))
- ;; C-c C-i prefix for gpr-query minor mode
-
- (define-key map "\C-c\C-i\C-d" 'gpr-query-goto-declaration)
- (define-key map "\C-c\C-i\C-p" 'ada-build-prompt-select-prj-file)
- (define-key map "\C-c\C-i\C-q" 'gpr-query-refresh)
- (define-key map "\C-c\C-i\C-r" 'gpr-query-show-references)
- ;; IMPROVEME: (define-key map "\C-c\M-d" 'gpr-query-parents)
- ;; IMPROVEME: overriding
- map
- ) "Local keymap used for gpr query minor mode.")
-
-(defvar gpr-query-menu (make-sparse-keymap "gpr-query"))
-(easy-menu-define gpr-query-menu gpr-query-map "Menu keymap for gpr-query
minor mode"
- '("gpr-query"
- ["Find and select project ..." ada-build-prompt-select-prj-file t]
- ["Select project ..." ada-prj-select t]
- ["Show current project" ada-prj-show t]
- ["Show gpr-query buffer" gpr-query-show-buffer t]
- ["Next compilation error" next-error t]
- ["Show secondary error" ada-show-secondary-error t]
- ["Goto declaration/body" gpr-query-goto-declaration t]
- ["Show parent declarations" ada-show-declaration-parents t]
- ["Show references" gpr-query-show-references t]
- ;; ["Show overriding" gpr-query-show-overriding t]
- ;; ["Show overridden" gpr-query-show-overridden t]
- ["Refresh cross reference cache" gpr-query-refresh t]
- ))
-
-(define-minor-mode gpr-query
- "Minor mode for navigating sources using GNAT cross reference tool.
-Enable mode if ARG is positive."
- :initial-value t
- :lighter " gpr-query" ;; mode line
-
- ;; just enable the menu and keymap
- )
-
-;;;;; support for Ada mode
-
-(defun gpr-query-refresh (delete-files)
- "For `ada-xref-refresh-function', using gpr_query."
- (interactive "P")
- ;; Kill the current session and delete the database, to get changed
- ;; env vars etc when it restarts.
- ;;
- ;; We need to delete the database files if the compiler version
- ;; changed, or the database was built with an incorrect environment
- ;; variable, or something else screwed up. However, rebuilding after
- ;; that is a lot slower, so we only do that on request.
- (let* ((session (gpr-query-cached-session))
- (db-filename
- (with-current-buffer (gpr-query-session-send "db_name" t)
- (goto-char (point-min))
- (buffer-substring-no-properties (line-beginning-position)
(line-end-position)))))
-
- (gpr-query-kill-session session)
- (when delete-files
- (delete-file db-filename))
- (gpr-query--start-process session)))
-
-(defun gpr-query-other (identifier file line col)
- "For `ada-xref-other-function', using gpr_query.
-FILE must be non-nil; line, col can be nil."
- (when (eq ?\" (aref identifier 0))
- ;; gpr_query wants the quotes stripped
- (setq col (+ 1 col))
- (setq identifier (substring identifier 1 (1- (length identifier))))
- )
-
- (setq file (gpr-query--normalize-filename file))
-
- (let ((cmd (format "refs %s:%s:%s:%s"
- identifier
- (file-name-nondirectory file)
- (or line "")
- (if col (1+ col) "")))
- (decl-loc nil)
- (body-loc nil)
- (search-type nil)
- (min-distance most-positive-fixnum)
- (result nil))
-
- (with-current-buffer (gpr-query-session-send cmd t)
- ;; 'gpr_query 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 file:line:column (type)
- ;; 1 2 3 4
- ;;
- ;; '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)
- ;;
- ;;
itc_assert:/home/Projects/GDS/work_stephe_2/common/itc/opsim/itc_dscovr_gdsi/Gds1553/src/Gds1553.cpp:830:9
(reference)
-
- (message "parsing result ...")
-
- (goto-char (point-min))
-
- (while (not (eobp))
- (cond
- ((looking-at gpr-query-ident-file-type-regexp)
- ;; process line
- (let* ((found-file (match-string 1))
- (found-line (string-to-number (match-string 2)))
- (found-col (string-to-number (match-string 3)))
- (found-type (match-string 4))
- (dist (if (and line col)
- (gpr-query-dist found-line line found-col col)
- most-positive-fixnum))
- )
-
- (setq found-file (gpr-query--normalize-filename found-file))
-
- (cond
- ((string-equal found-type "declaration")
- (setq decl-loc (list found-file found-line (1- found-col))))
-
- ((or
- (string-equal found-type "body")
- (string-equal found-type "full declaration"))
- (setq body-loc (list found-file found-line (1- found-col))))
- )
-
- (when (and (equal found-file file)
- (or
- (string-equal found-type "body")
- (string-equal found-type "declaration"))
- (<= dist min-distance))
- ;; The source may have changed since the xref database
- ;; was computed, so allow for fuzzy matches.
- (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
- ((and
- line
- (string-equal search-type "declaration")
- body-loc)
- ;; We started the search on the declaration; find the body
- (setq result body-loc))
-
- ((and
- (not line)
- (string-equal search-type "declaration"))
- ;; We started in the spec file; find the declaration
- ;;
- ;; If the file has both declaration and body, this will go to
- ;; declaration. Then a search with line, col can go to body.
- (setq result decl-loc))
-
- ((and
- (not line)
- (string-equal search-type "body"))
- ;; We started in the body file; find the body
- (setq result body-loc))
-
- (decl-loc
- (setq result decl-loc))
- )
-
- (when (null result)
- (error "gpr_query did not return other item; refresh?"))
-
- (message "parsing result ... done")
- result)))
-
-(defun gpr-query-all (identifier file line col &optional _local-only _append)
- "For `ada-xref-all-function', using gpr_query."
- ;; FIXME: implement local-only, append
- (gpr-query-compilation identifier file line col "refs"
'gpr-query-ident-file))
-
-(defun gpr-query-parents (identifier file line col)
- "For `ada-xref-parent-function', using gpr_query."
- (gpr-query-compilation identifier file line col "parent_types"
'gpr-query-ident-file))
-
-(defun gpr-query-overriding (identifier file line col)
- "For `ada-xref-overriding-function', using gpr_query."
- (gpr-query-compilation identifier file line col "overriding"
'gpr-query-ident-file))
-
-(defun gpr-query-overridden-1 (identifier file line col)
- "For `ada-xref-overridden-function', using gpr_query."
- (when (eq ?\" (aref identifier 0))
- ;; gpr_query wants the quotes stripped
- (setq col (+ 1 col))
- (setq identifier (substring identifier 1 (1- (length identifier))))
- )
-
- (let ((cmd (format "overridden %s:%s:%d:%d" identifier
(file-name-nondirectory file) line (1+ col)))
- result)
- (with-current-buffer (gpr-query-session-send cmd t)
-
- (goto-char (point-min))
- (when (looking-at gpr-query-ident-file-regexp)
- (setq result
- (list
- (match-string 1)
- (string-to-number (match-string 2))
- (string-to-number (match-string 3)))))
-
- (when (null result)
- (error "gpr_query did not return a result; refresh?"))
-
- (message "parsing result ... done")
- result)))
-
-(defun gpr-query--normalize-filename (file)
- "Takes account of filesystem differences."
- (when (eq system-type 'windows-nt)
- ;; 'expand-file-name' converts Windows directory
- ;; separators to normal Emacs. Since Windows file
- ;; system is case insensitive, GNAT and Emacs can
- ;; disagree on the case, so convert all to lowercase.
- (setq file (downcase (expand-file-name file))))
- (when (eq system-type 'darwin)
- ;; case-insensitive case-preserving; so just downcase
- (setq file (downcase file)))
- file
- )
-
-(defun ada-gpr-query-select-prj ()
- ;; We wait until the session is actually required to create it.
- (setq ada-file-name-from-ada-name 'ada-gnat-file-name-from-ada-name)
- (setq ada-ada-name-from-file-name 'ada-gnat-ada-name-from-file-name)
- (setq ada-make-package-body 'ada-gnat-make-package-body)
-
- (setq ada-xref-refresh-function 'gpr-query-refresh)
- (setq ada-xref-all-function 'gpr-query-all)
- (setq ada-xref-other-function 'gpr-query-other)
- (setq ada-xref-parent-function 'gpr-query-parents)
- (setq ada-xref-all-function 'gpr-query-all)
- (setq ada-xref-overriding-function 'gpr-query-overriding)
- (setq ada-xref-overridden-function 'gpr-query-overridden-1)
- (setq ada-show-xref-tool-buffer 'gpr-query-show-buffer)
-
- (when (fboundp 'xref-ada-mode)
- (xref-ada-mode 1))
-
- (add-to-list 'completion-ignored-extensions ".ali") ;; gnat library files,
used for cross reference
- )
-
-(defun ada-gpr-query-deselect-prj ()
- ;; We don’t kill the session here; user may switch back to this
- ;; project.
- (setq ada-file-name-from-ada-name nil)
- (setq ada-ada-name-from-file-name nil)
- (setq ada-make-package-body nil)
-
- (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 ada-show-xref-tool-buffer nil)
-
- (when (fboundp 'xref-ada-mode)
- (xref-ada-mode 0))
-
- (setq completion-ignored-extensions (delete ".ali"
completion-ignored-extensions))
- )
-
-(defun ada-gpr-query ()
- "Set Ada mode global vars to use gpr_query."
- (add-to-list 'ada-prj-parser-alist '("gpr" . gnat-parse-gpr))
- (add-to-list 'ada-select-prj-xref-tool '(gpr_query .
ada-gpr-query-select-prj))
- (add-to-list 'ada-deselect-prj-xref-tool '(gpr_query .
ada-gpr-query-deselect-prj))
-
- ;; no parse-*-xref
- )
-
-(provide 'gpr-query)
-
-(add-to-list 'compilation-error-regexp-alist-alist
- (cons 'gpr-query-ident-file gpr-query-ident-file-regexp-alist))
-
-(ada-gpr-query)
-
-;;; end of file
+;; gpr-query.el --- Minor mode for navigating sources using gpr_query -*-
lexical-binding:t -*-
+;;
+;; gpr-query supports Ada and any gcc language that supports the
+;; AdaCore -fdump-xref switch (which includes C, C++).
+;;
+;; Copyright (C) 2013 - 2020 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 gpr-query
+
+(require 'cl-lib)
+(require 'compile)
+(require 'gnat-core)
+(require 'xref)
+(require 'wisi-prj)
+
+(defgroup gpr-query nil
+ "gpr_query cross reference tool"
+ :group 'tools)
+
+(defcustom gpr-query-exec "gpr_query"
+ "Executable for gpr_query."
+ :type 'string)
+
+(defcustom gpr-query-env nil
+ "Environment variables needed by the gpr_query executable.
+Value must be alist where each element is \"<name>=<value>\""
+ ;; This could also be provided as a project file setting, But it is
+ ;; intended for LD_LIBRARY_PATH (info "(ada-mode)Ada executables"),
+ ;; which must be set for all projects on the system.
+ :type 'string)
+
+(defconst gpr-query-protocol-version "2"
+ "Defines data exchanged between this package and the background process.
+Must match gpr_query.adb Version.")
+
+;;;;; sessions
+
+;; gpr_query 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 gpr_query
+;; 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 (gpr-query--session)
+ (process nil) ;; running gpr_query
+ (buffer nil)) ;; receives output of gpr_query; default-directory gives
location of db
+
+;; Starting the buffer name with a space hides it from some lists, and
+;; also disables font-lock. We sometimes use it to display xref
+;; locations in compilation-mode, so we want font-lock enabled.
+;;
+;; IMPROVEME: copy the xref info to a true user buffer, optionally an
+;; *xref* buffer.
+(defconst gpr-query-buffer-name-prefix "*gpr_query-")
+
+(defvar gpr-query--debug-start nil)
+
+(defun gpr-query--start-process (project session)
+ "Start the session process running gpr_query."
+ (unless (buffer-live-p (gpr-query--session-buffer session))
+ ;; user may have killed buffer
+ (setf (gpr-query--session-buffer session)
+ (gnat-run-buffer project (gnat-compiler-run-buffer-name
(wisi-prj-xref project))))
+ (with-current-buffer (gpr-query--session-buffer session)
+ (compilation-mode)
+ (setq buffer-read-only nil)))
+
+ (with-current-buffer (gpr-query--session-buffer session)
+ (let ((process-environment
+ (append
+ (wisi-prj-compile-env project)
+ (wisi-prj-file-env project)
+ gpr-query-env
+ (copy-sequence process-environment)))
+ (gpr-file (file-name-nondirectory (gnat-compiler-gpr-file
(wisi-prj-xref project)))))
+
+ (erase-buffer); delete any previous messages, prompt
+ (setf (gpr-query--session-process session)
+ (apply #'start-process
+ (concat "gpr_query " (buffer-name))
+ (gpr-query--session-buffer session)
+ gpr-query-exec
+ (cl-delete-if
+ 'null
+ (list
+ (concat "--project=" gpr-file)
+ (when gpr-query--debug-start
+ (concat "--tracefile=gpr_query.trace")
+ ;; The file gpr_query.trace should contain: gpr_query=yes
+ )))))
+ (set-process-query-on-exit-flag (gpr-query--session-process session) nil)
+ (gpr-query-session-wait session)
+
+ (if (process-live-p (gpr-query--session-process session))
+ (progn
+ (goto-char (point-min))
+ (if (search-forward-regexp "version: \\([0-9]+\\)$")
+ (unless (string-equal (match-string 1)
gpr-query-protocol-version)
+ (user-error "gpr-query version mismatch: elisp %s process %s"
+ gpr-query-protocol-version
+ (match-string 1)))
+ (user-error "gpr-query is an old version; expecting %s"
gpr-query-protocol-version))
+
+ ;; Check for warnings about invalid directories etc. But some
+ ;; warnings are tolerable, so only abort if process actually
+ ;; died.
+ (goto-char (point-min))
+ (when (search-forward "warning:" nil t)
+ (if debug-on-error
+ (error "gpr_query warnings")
+ (beep)
+ (message "gpr_query warnings"))))
+
+ (error "gpr-query process failed to start"))
+ )))
+
+(defun gpr-query--make-session (project)
+ "Create and return a session for the current project file."
+ (let ((session
+ (make-gpr-query--session
+ :buffer nil
+ :process nil)))
+ (gpr-query--start-process project session)
+ session))
+
+(defvar gpr-query--sessions '()
+ "Assoc list of sessions, indexed by absolute GNAT project file name.")
+
+(defun gpr-query-cached-session (project)
+ "Return a session for PROJECT, creating it if necessary."
+ (let* ((gpr-file (gnat-compiler-gpr-file (wisi-prj-xref project)))
+ (session (cdr (assoc gpr-file gpr-query--sessions))))
+ (if session
+ (progn
+ (unless (process-live-p (gpr-query--session-process session))
+ (gpr-query--start-process project session))
+ session)
+ ;; else
+ (prog1
+ (setq session (gpr-query--make-session project))
+ (push (cons gpr-file session) gpr-query--sessions)))
+ ))
+
+(defconst gpr-query-prompt "^>>> $"
+ ;; gpr_query output ends with this
+ "Regexp matching gpr_query prompt; indicates previous command is complete.")
+
+(defun gpr-query-session-wait (session)
+ "Wait for the current command to complete."
+ (unless (process-live-p (gpr-query--session-process session))
+ (gpr-query-show-buffer session)
+ (error "gpr-query process died"))
+
+ (with-current-buffer (gpr-query--session-buffer session)
+ (let ((process (gpr-query--session-process session))
+ (search-start (point-min))
+ (wait-count 0))
+ (while (and (process-live-p process)
+ (progn
+ ;; process output is inserted before point, so move back
over it to search it
+ (goto-char search-start)
+ (not (re-search-forward gpr-query-prompt (point-max) 1))))
+ (setq search-start (point));; don't search same text again
+ (message (concat "running gpr_query ..." (make-string wait-count ?.)))
+ ;; IMPROVEME: use --display-progress
+ (accept-process-output process 1.0)
+ (setq wait-count (1+ wait-count)))
+ (if (process-live-p process)
+ (message (concat "running gpr_query ... done"))
+ (gpr-query-show-buffer session)
+ (error "gpr_query process died"))
+ )))
+
+(defun gpr-query-session-send (session cmd wait)
+ "Send CMD to gpr_query session for GPR-FILE.
+If WAIT is non-nil, wait for command to complete.
+Return buffer that holds output."
+ ;; always wait for previous command to complete; also checks for
+ ;; dead process.
+ (gpr-query-session-wait session)
+ (with-current-buffer (gpr-query--session-buffer session)
+ (erase-buffer)
+ (process-send-string (gpr-query--session-process session)
+ (concat cmd "\n"))
+ (when wait
+ (gpr-query-session-wait session))
+ (current-buffer)
+ ))
+
+(defun gpr-query-kill-session (session)
+ (let ((process (gpr-query--session-process session)))
+ (when (process-live-p process)
+ (process-send-string (gpr-query--session-process session) "exit\n")
+ (while (process-live-p process)
+ (accept-process-output process 1.0)))
+ ))
+
+(defun gpr-query-kill-all-sessions ()
+ (interactive)
+ (let ((count 0))
+ (mapc (lambda (assoc)
+ (let ((session (cdr assoc)))
+ (when (process-live-p (gpr-query--session-process session))
+ (setq count (1+ count))
+ (process-send-string (gpr-query--session-process session)
"exit\n")
+ )))
+ gpr-query--sessions)
+ (message "Killed %d sessions" count)
+ ))
+
+(defun gpr-query-show-buffer (session)
+ (interactive)
+ (pop-to-buffer (gpr-query--session-buffer session)))
+
+;;;;; utils
+
+(defun gpr-query-get-src-dirs (project src-dirs)
+ "Append list of source dirs in gpr project PROJECT to SRC-DIRS.
+Uses `gpr_query'. Returns new list."
+
+ (let ((session (gpr-query-cached-session project)))
+ (with-current-buffer (gpr-query-session-send session "source_dirs" t)
+ (goto-char (point-min))
+ (while (not (looking-at gpr-query-prompt))
+ (cl-pushnew
+ (expand-file-name ; Canonicalize path part.
+ (directory-file-name
+ (buffer-substring-no-properties (point) (point-at-eol))))
+ src-dirs :test #'equal)
+ (forward-line 1))
+ ))
+ src-dirs)
+
+(defun gpr-query-get-prj-dirs (project prj-dirs)
+ "Append list of project dirs in gpr project PROJECT to PRJ-DIRS.
+Uses `gpr_query'. Returns new list."
+
+ (let ((session (gpr-query-cached-session project)))
+ (with-current-buffer (gpr-query-session-send session "project_path" t)
+ (goto-char (point-min))
+ (while (not (looking-at gpr-query-prompt))
+ (cl-pushnew
+ (let ((dir (buffer-substring-no-properties (point) (point-at-eol))))
+ (if (string= dir ".")
+ (directory-file-name default-directory)
+ (expand-file-name dir))) ; Canonicalize path part.
+ prj-dirs
+ :test #'equal)
+ (forward-line 1))
+ ))
+ prj-dirs)
+
+(defconst gpr-query-ident-file-regexp
+ ;;
C:\Projects\GDS\work_dscovr_release\common\1553\gds-mil_std_1553-utf.ads:252:25
+ ;;
/Projects/GDS/work_dscovr_release/common/1553/gds-mil_std_1553-utf.ads:252:25
+ ;; gds-mil_std_1553-utf.ads:252:25 - when wisi-xref-full-path is nil
+ "\\(\\(?:.:\\\\\\|/\\)?[^:]*\\):\\([0-9]+\\):\\([0-9]+\\)"
+ ;; 1 2 3
+ "Regexp matching <file>:<line>:<column> where <file> is an absolute file
name or basename.")
+
+(defconst gpr-query-ident-file-regexp-alist
+ (list (concat "^" gpr-query-ident-file-regexp) 1 2 3)
+ "For compilation-error-regexp-alist, matching gpr_query output")
+
+(defconst gpr-query-ident-file-type-regexp
+ (concat gpr-query-ident-file-regexp " (\\(.*\\))")
+ "Regexp matching <file>:<line>:<column> (<type>)")
+
+(defun gpr-query-compilation (project identifier file line col cmd comp-err
&optional local_only append)
+ "Run gpr_query CMD IDENTIFIER:FILE:LINE:COL,
+with compilation-error-regexp-alist set to COMP-ERR."
+ ;; Useful when gpr_query will return a list of references; the user
+ ;; can navigate to each result in turn via `next-error'.
+
+ ;; Emacs column is 0-indexed, gpr_query is 1-indexed.
+ (let* ((cmd-1 (concat (format "%s %s:%s:%d:%d"
+ cmd identifier file line (1+ col))
+ (when (member cmd '("refs"))
+ (if local_only " local_only" " global"))
+ (when (member cmd '("overriding" "overridden_by"
"parent_types" "refs"))
+ (if wisi-xref-full-path " full_file_names" "
short_file_names"))))
+ (session (gpr-query-cached-session project))
+ (result-count 0)
+ start-pos prev-content
+ target-file target-line target-col)
+
+ (when append
+ (with-current-buffer (gpr-query--session-buffer session)
+ ;; don't include trailing prompt in `prev-content'
+ (goto-char (point-max))
+ (forward-line 0)
+ (setq prev-content (buffer-substring (point-min) (point)))))
+
+ (with-current-buffer (gpr-query-session-send session cmd-1 t)
+ ;; point is at EOB. gpr_query returns one line per result plus prompt,
warnings
+ (setq result-count (- (line-number-at-pos) 1))
+ (setq start-pos (point-min))
+
+ (setq buffer-read-only nil)
+ (when append
+ (goto-char (point-min))
+ (insert prev-content)
+ (setq start-pos (point))
+ (goto-char (point-max)))
+
+ (set (make-local-variable 'compilation-error-regexp-alist) (list
comp-err))
+
+ (compilation--flush-parse (point-min) (point-max))
+ (compilation--ensure-parse (point-max))
+
+ (goto-char start-pos)
+
+ (cond
+ ((looking-at "^warning: ")
+ (setq result-count (1- result-count))
+ (forward-line 1))
+ ((looking-at "^Error: entity not found")
+ (error (buffer-substring-no-properties (line-beginning-position)
(line-end-position))))
+ )
+
+ (cond
+ ((and (not append)
+ (= result-count 1))
+ ;; just go there, don't display session-buffer. We have to
+ ;; fetch the compilation-message while in the
+ ;; session-buffer. and call wisi-goto-source outside the
+ ;; with-current-buffer above.
+ (let* ((msg (compilation-next-error 0))
+ ;; IMPROVEME: '--' indicates internal-only. But we can't
+ ;; use compile-goto-error, because that displays the
+ ;; session-buffer.
+ (loc (compilation--message->loc msg)))
+ (setq target-file (caar (compilation--loc->file-struct loc))
+ target-line (caar (cddr (compilation--loc->file-struct loc)))
+ target-col (1- (compilation--loc->col loc))
+ )
+ ))
+
+ ((= result-count 0)
+ (error "gpr_query returned no results"))
+
+ (t
+ ;; for next-error, below
+ (setq next-error-last-buffer (current-buffer)))
+
+ ));; case, with-currrent-buffer
+
+ (if (and (not append)
+ (= result-count 1))
+ (wisi-goto-source target-file target-line target-col)
+
+ ;; more than one result; display session buffer, goto first ref
+ ;;
+ ;; compilation-next-error-function assumes there is not an error
+ ;; at point-min; work around that by moving forward 0 errors for
+ ;; the first one. Unless the first line contains "warning: ".
+ (pop-to-buffer next-error-last-buffer)
+ (goto-char start-pos)
+ (unless append
+ (if (looking-at "^warning: ")
+ (next-error 1 t)
+ (next-error 0 t)))
+ )
+ ))
+
+(defun gpr-query-dist (found-line line found-col col)
+ "Return distance between FOUND-LINE FOUND-COL and LINE COL."
+ (+ (abs (- found-col col))
+ (* (abs (- found-line line)) 250)))
+
+(defvar gpr-query-map
+ (let ((map (make-sparse-keymap)))
+ ;; C-c C-i prefix for gpr-query minor mode
+
+ (define-key map "\C-c\C-i\C-d" 'gpr-query-goto-declaration)
+ (define-key map "\C-c\C-i\C-q" 'gpr-query-refresh)
+ (define-key map "\C-c\C-i\C-r" 'gpr-query-show-references)
+ ;; IMPROVEME: (define-key map "\C-c\M-d" 'gpr-query-parents)
+ ;; IMPROVEME: overriding
+ map
+ ) "Local keymap used for gpr query minor mode.")
+
+(defvar gpr-query-menu (make-sparse-keymap "gpr-query"))
+(easy-menu-define gpr-query-menu gpr-query-map "Menu keymap for gpr-query
minor mode"
+ '("gpr-query"
+ ["Show gpr-query buffer" gpr-query-show-buffer t]
+ ["Next xref" next-error t]
+ ["Goto declaration/body" xref-find-definitions t]
+ ["Show parent declarations" wisi-show-declaration-parents t]
+ ["Show references" wisi-show-references t]
+ ["Show overriding" wisi-show-overriding t]
+ ["Show overridden" wisi-show-overridden t]
+ ["Refresh cross reference cache" wisi-refresh-prj-cache t]
+ ))
+
+(define-minor-mode gpr-query
+ "Minor mode for navigating sources using GNAT cross reference tool.
+Enable mode if ARG is positive."
+ :initial-value t
+ :lighter " gpr-query" ;; mode line
+
+ ;; just enable the menu and keymap
+ )
+
+(defun gpr-query--normalize-filename (file)
+ "Convert FILE from native format to Emacs standard.
+FILE is from gpr-query."
+ ;; FILE must be abs
+ (cond
+ ((eq system-type 'windows-nt)
+ ;; 'expand-file-name' converts Windows directory
+ ;; separators to normal Emacs. Since Windows file
+ ;; system is case insensitive, GNAT and Emacs can
+ ;; disagree on the case, so convert all to lowercase.
+ (downcase (expand-file-name file)))
+
+ ((eq system-type 'darwin)
+ ;; case-insensitive case-preserving; so just downcase
+ (downcase file))
+
+ (t ;; linux
+ file))
+ )
+
+;;;;; wisi-xref methods
+
+(cl-defstruct (gpr-query-xref (:include gnat-compiler))
+ ;; no new slots
+ )
+
+;;;###autoload
+(cl-defun create-gpr_query-xref
+ (&key
+ gpr-file
+ run-buffer-name
+ project-path
+ target
+ runtime
+ gnat-stub-opts
+ gnat-stub-cargs)
+ ;; See note on `create-ada-prj' for why this is not a defalias.
+ (make-gpr-query-xref
+ :gpr-file gpr-file
+ :run-buffer-name run-buffer-name
+ :project-path project-path
+ :target target
+ :runtime runtime
+ :gnat-stub-opts gnat-stub-opts
+ :gnat-stub-cargs gnat-stub-cargs
+ ))
+
+(cl-defmethod wisi-xref-parse-one ((xref gpr-query-xref) project name value)
+ (wisi-compiler-parse-one xref project name value))
+
+(cl-defmethod wisi-xref-parse-final ((xref gpr-query-xref) _project
prj-file-name)
+ (setf (gnat-compiler-run-buffer-name xref) (gnat-run-buffer-name
prj-file-name gpr-query-buffer-name-prefix))
+ (unless (gnat-compiler-gpr-file xref)
+ (if (string= "gpr" (file-name-extension prj-file-name))
+ (setf (gnat-compiler-gpr-file xref) prj-file-name)
+ (user-error "using gpr-query xref, but no gpr file provided"))))
+
+(cl-defmethod wisi-xref-refresh-cache ((_xref gpr-query-xref) project no-full)
+ ;; Kill the current session and delete the database, to get changed
+ ;; env vars etc when it restarts.
+ ;;
+ ;; We need to delete the database files if the compiler version
+ ;; changed, or the database was built with an incorrect environment
+ ;; variable, or something else screwed up. However, rebuilding after
+ ;; that is a lot slower, so we only do that with permission.
+ (let* ((session (gpr-query-cached-session project))
+ (db-filename
+ (with-current-buffer (gpr-query-session-send session "db_name" t)
+ (goto-char (point-min))
+ (buffer-substring-no-properties (line-beginning-position)
(line-end-position)))))
+
+ (gpr-query-kill-session session)
+ (unless no-full
+ (delete-file db-filename))
+
+ ;; We do this here because the user expects to see the "running
+ ;; gpr_query ..." message now, not later when a gpr-query command
+ ;; is run.
+ (gpr-query--start-process project session)
+ ))
+
+(defun gpr-query-tree-refs (project item op)
+ "Run gpr_query tree command OP on ITEM (an xref-item), return list of
xref-items."
+ (with-slots (summary location) item
+ ;; 'location' may have line, column nil
+ (let ((eieio-skip-typecheck t))
+ (with-slots (file line column) location
+ (when (eq ?\" (aref summary 0))
+ ;; gpr_query wants the quotes stripped
+ (when column (setq column (+ 1 column)))
+ (setq summary (substring summary 1 (1- (length summary)))))
+
+ (let ((cmd (format "%s %s:%s:%s:%s full_file_names"
+ op
+ summary
+ (file-name-nondirectory file)
+ (or line "")
+ (if column (1+ column) "")))
+ (result nil)
+ (session (gpr-query-cached-session project)))
+
+ (with-current-buffer (gpr-query-session-send session cmd t)
+ ;; 'gpr_query tree_*' returns a list containing the declarations,
+ ;; bodies, and references (classwide), in no particular order.
+ ;;
+ ;; the format of each line is file:line:column (type)
+ ;; 1 2 3 4
+ ;;
+ ;; 'type' includes the type name
+
+ (goto-char (point-min))
+
+ (while (not (eobp))
+ (cond
+ ((looking-at gpr-query-ident-file-type-regexp)
+ ;; process line
+ (let* ((found-file (match-string 1))
+ (found-line (string-to-number (match-string 2)))
+ (found-col (1- (string-to-number (match-string 3))))
+ (found-type (match-string 4))
+ )
+
+ (unless found-file
+ ;; Can be nil if actual file is renamed but gpr-query
+ ;; database not updated. We abort, rather than just
+ ;; ignoring this entry, because it means other ref are
+ ;; probably out of date as well.
+ (user-error "file '%s' not found; refresh?" (match-string
1)))
+
+ (setq found-file (gpr-query--normalize-filename found-file))
+
+ (push (xref-make
+ (cond
+ ((string= op "tree_refs")
+ (if found-type
+ (if (string-match ";" found-type)
+ ;; ref is to the identifier
+ (concat summary " " found-type)
+ ;; ref is to the controlling type of the
identifier
+ found-type)
+ summary))
+
+ ((string= op "tree_defs")
+ found-type)
+ )
+ (xref-make-file-location found-file found-line
found-col))
+ result)
+ ))
+
+ (t ;; ignore line
+ ;;
+ ;; This skips GPR_PROJECT_PATH and echoed command at start of
buffer.
+ ;;
+ ;; It also skips warning lines.
+ )
+ )
+ (forward-line 1)
+ )
+
+ (when (null result)
+ (user-error "gpr_query did not return any references; refresh?"))
+
+ (nreverse result) ;; root of tree first.
+ ))))))
+
+(cl-defmethod wisi-xref-definitions ((_xref gpr-query-xref) project item)
+ (gpr-query-tree-refs project item "tree_defs"))
+
+(cl-defmethod wisi-xref-references ((_xref gpr-query-xref) project item)
+ (gpr-query-tree-refs project item "tree_refs"))
+
+(cl-defmethod wisi-xref-other ((_xref gpr-query-xref) project &key identifier
filename line column)
+ (when (eq ?\" (aref identifier 0))
+ ;; gpr_query wants the quotes stripped
+ (setq column (+ 1 column))
+ (setq identifier (substring identifier 1 (1- (length identifier))))
+ )
+
+ (let ((temp filename))
+
+ (unless (file-name-absolute-p temp)
+ (setq temp (locate-file filename compilation-search-path)))
+
+ (if temp
+ (setq filename temp)
+ (user-error "'%s' not found in current project - renamed?" filename)))
+
+ (setq filename (gpr-query--normalize-filename filename))
+
+ (let ((cmd (format "refs %s:%s:%s:%s global full_file_names"
+ identifier
+ (file-name-nondirectory filename)
+ (or line "")
+ (if column (1+ column) "")))
+ (decl-loc nil)
+ (body-loc nil)
+ (search-type nil)
+ (min-distance most-positive-fixnum)
+ (result nil)
+ (session (gpr-query-cached-session project)))
+
+ (with-current-buffer (gpr-query-session-send session cmd t)
+ ;; 'gpr_query 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 file:line:column (type)
+ ;; 1 2 3 4
+ ;;
+ ;; '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)
+ ;;
+ ;;
itc_assert:/home/Projects/GDS/work_stephe_2/common/itc/opsim/itc_dscovr_gdsi/Gds1553/src/Gds1553.cpp:830:9
(reference)
+
+ (message "parsing result ...")
+
+ (goto-char (point-min))
+
+ (while (not (eobp))
+ (cond
+ ((looking-at gpr-query-ident-file-type-regexp)
+ ;; process line
+ (let* ((found-file (match-string 1))
+ (found-line (string-to-number (match-string 2)))
+ (found-col (string-to-number (match-string 3)))
+ (found-type (match-string 4))
+ (dist (if (and line column)
+ (gpr-query-dist found-line line found-col
column)
+ most-positive-fixnum))
+ )
+
+ (unless found-file
+ ;; can be nil if actual file is renamed but gpr-query database
not updated
+ (error "file '%s' not found; refresh?" (match-string 1)))
+
+ (setq found-file (gpr-query--normalize-filename found-file))
+
+ (cond
+ ((string-equal found-type "declaration")
+ (setq decl-loc (list found-file found-line (1- found-col))))
+
+ ((or
+ (string-equal found-type "body")
+ (string-equal found-type "full declaration"))
+ (setq body-loc (list found-file found-line (1- found-col))))
+ )
+
+ (when (and (equal found-file filename)
+ (or
+ (string-equal found-type "body")
+ (string-equal found-type "full declaration")
+ (string-equal found-type "declaration"))
+ (<= dist min-distance))
+ ;; The source may have changed since the xref database
+ ;; was computed, so allow for fuzzy matches.
+ (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
+ ((and
+ line
+ (string-equal search-type "declaration")
+ body-loc)
+ ;; We started the search on the declaration; find the body
+ (setq result body-loc))
+
+ ((and
+ (not line)
+ (string-equal search-type "declaration"))
+ ;; We started in the spec file; find the declaration
+ ;;
+ ;; If the file has both declaration and body, this will go to
+ ;; declaration. Then a search with line, column can go to body.
+ (setq result decl-loc))
+
+ ((and
+ (not line)
+ (or
+ (string-equal search-type "body")
+ (string-equal search-type "full declaration")))
+ ;; We started n the body file; find the body
+ (setq result body-loc))
+
+ (decl-loc
+ (setq result decl-loc))
+ )
+
+ (when (null result)
+ (error "gpr_query did not return other item; refresh?"))
+
+ (message "parsing result ... done")
+ result)))
+
+(cl-defmethod wisi-xref-parents ((_xref gpr-query-xref) project &key
identifier filename line column)
+ (gpr-query-compilation project identifier filename line column
"parent_types" 'gpr-query-ident-file))
+
+(cl-defmethod wisi-xref-all ((_xref gpr-query-xref) project &key identifier
filename line column local-only append)
+ (gpr-query-compilation project identifier filename line column "refs"
'gpr-query-ident-file local-only append))
+
+(cl-defmethod wisi-xref-overriding ((_xref gpr-query-xref) project &key
identifier filename line column)
+ (gpr-query-compilation project identifier filename line column "overriding"
'gpr-query-ident-file))
+
+(cl-defmethod wisi-xref-overridden ((_xref gpr-query-xref) project &key
identifier filename line column)
+ (when (eq ?\" (aref identifier 0))
+ ;; gpr_query wants the quotes stripped
+ (setq column (+ 1 column))
+ (setq identifier (substring identifier 1 (1- (length identifier))))
+ )
+
+ (let ((cmd (format "overridden %s:%s:%d:%d %s"
+ identifier (file-name-nondirectory filename) line (1+
column)
+ (if wisi-xref-full-path "full_file_names"
"short_file_names")))
+ (session (gpr-query-cached-session project))
+ result)
+ (with-current-buffer (gpr-query-session-send session cmd t)
+
+ (goto-char (point-min))
+ (when (looking-at gpr-query-ident-file-regexp)
+ (setq result
+ (list
+ (match-string 1)
+ (string-to-number (match-string 2))
+ (string-to-number (match-string 3)))))
+
+ (when (null result)
+ (error "gpr_query did not return a result; refresh?"))
+
+ (message "parsing result ... done")
+ result)))
+
+(add-to-list 'compilation-error-regexp-alist-alist
+ (cons 'gpr-query-ident-file gpr-query-ident-file-regexp-alist))
+
+(provide 'gpr-query)
+;;; end of file
diff --git a/packages/ada-mode/gpr-skel.el b/packages/ada-mode/gpr-skel.el
index 71ca257..3f0cb0f 100644
--- a/packages/ada-mode/gpr-skel.el
+++ b/packages/ada-mode/gpr-skel.el
@@ -1,6 +1,6 @@
;; gpr-skel.el --- Extension to gpr-mode for inserting statement skeletons
-*- lexical-binding:t -*-
-;; Copyright (C) 2013-2015, 2018 Free Software Foundation, Inc.
+;; Copyright (C) 2013-2015, 2018, 2019 Free Software Foundation, Inc.
;; Authors: Stephen Leake <address@hidden>
@@ -21,7 +21,7 @@
;;; Design:
;;
-;; The primary user command is `gpr-skel-expand', which inserts the
+;; The primary user command is `wisi-skel-expand', which inserts the
;; skeleton associated with the previous word (possibly skipping a
;; name).
;;
@@ -37,7 +37,7 @@
;; Created Dec 2013
(require 'skeleton)
-(require 'gpr-mode)
+(require 'wisi-skel)
;;;;; user variables, example skeletons intended to be overwritten
@@ -109,140 +109,6 @@ Each user will probably want to override this."
_
"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 " | ") " | ... : "))
- ))
-
-(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 `skeleton-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 this 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-len (if (sequencep pending-undo-list) (length
pending-undo-list) 0)))
- (undo-boundary)
- (condition-case nil
- (progn
- (skeleton-expand)
- t)
- (error
- ;; undo hook action if any
- (unless (= undo-len (if (sequencep pending-undo-list) (length
pending-undo-list) 0))
- (undo))
-
- ;; undo motion
- (goto-char pos)
- nil)))))
-
-(defun skeleton-next-placeholder ()
- "Move point forward to start of next placeholder."
- (interactive)
- (skip-syntax-forward "^!"))
-
-(defun skeleton-prev-placeholder ()
- "Move point forward to start of next placeholder."
- (interactive)
- (skip-syntax-backward "^!"))
-
-;; end FIXME:
-
;;;;; token alist, setup
(defconst gpr-skel-token-alist
@@ -253,22 +119,18 @@ it is a name, and use the word before that as the token."
("header" . gpr-skel-header)
("package" . gpr-skel-package)
("project" . gpr-skel-project))
-"For skeleton-token-alist")
+"For `wisi-skel-token-alist', used by `wisi-skel-expand'.")
(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)
+ "Setup a buffer for gpr-skel."
+ (setq wisi-skel-token-alist gpr-skel-token-alist)
+ (add-hook 'skeleton-end-hook 'wisi-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)
+(provide 'gpr-skel)
;;; end of file
diff --git a/packages/ada-mode/gpr-wisi.el b/packages/ada-mode/gpr-wisi.el
deleted file mode 100644
index bff3a65..0000000
--- a/packages/ada-mode/gpr-wisi.el
+++ /dev/null
@@ -1,133 +0,0 @@
-;; gpr-wisi.el --- Indentation engine for gpr mode, using the wisi parser -*-
lexical-binding:t -*-
-;;
-;; Copyright (C) 2013 - 2019 Free Software Foundation, Inc.
-;;
-;; Author: Stephen Leake <address@hidden>
-;;
-;; This file is part of GNU Emacs.
-;;
-;; GNU Emacs is free software: you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-;;
-;; GNU Emacs is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-;; GNU General Public License for more details.
-;;
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
-;;
-;;; History: first version Jan 2013
-;;
-;;;;
-
-(require 'cl-lib)
-(require 'gpr-indent-user-options)
-(require 'gpr-mode)
-(require 'gpr-process)
-(require 'wisi)
-(require 'wisi-process-parse)
-
-(defconst gpr-wisi-language-protocol-version "1"
- "Defines language-specific parser parameters.
-Must match wisi-gpr.ads Language_Protocol_Version.")
-
-(defun gpr-wisi-which-function ()
- "For `gpr-which-function'."
- (wisi-validate-cache (point-min) (point) nil 'navigate)
- ;; No message on parse fail, since this could be called from
which-function-mode
- (when (wisi-cache-covers-pos 'navigate (point))
- (let ((cache (wisi-backward-cache))
- done
- project-pos
- package-pos
- decl-pos)
- (while (and cache (not done))
- ;; find attribute_declaration and package containing point (if any)
- (cond
- ((not (eq (wisi-cache-class cache) 'statement-start))
- nil)
-
- ((eq (wisi-cache-nonterm cache) 'attribute_declaration)
- (setq decl-pos (point)))
-
- ((eq (wisi-cache-nonterm cache) 'package_spec)
- (setq package-pos (point))
- (setq done t))
-
- ((eq (wisi-cache-nonterm cache) 'simple_project_declaration)
- (setq project-pos (point))
- (setq done t))
- )
-
- (setq cache (wisi-goto-containing cache)))
-
- (cond
- (package-pos
- (goto-char package-pos)
- (setq done t))
-
- (decl-pos
- (goto-char decl-pos)
- (setq done t))
-
- (project-pos
- (goto-char project-pos)
- (setq done t))
-
- (t ;; before project
- (setq done nil))
- )
-
- (when done
- (wisi-next-name))
-
- )))
-
-;;;;
-
-(cl-defstruct (gpr-wisi-parser (:include wisi-process--parser))
- ;; no new structs
- )
-
-(cl-defmethod wisi-parse-format-language-options ((_parser gpr-wisi-parser))
- (format "%d %d %d"
- gpr-indent
- gpr-indent-broken
- gpr-indent-when
- ))
-
-(defvar gpr-process-face-table nil) ;; gpr-process.el
-(defvar gpr-process-token-table nil) ;;gpr-process.el
-
-(defun gpr-wisi-setup ()
- "Set up a buffer for parsing gpr files with wisi."
- (wisi-setup
- :indent-calculate nil
- :post-indent-fail nil
- :parser
- (wisi-process-parse-get
- (make-gpr-wisi-parser
- :label "gpr"
- :language-protocol-version gpr-wisi-language-protocol-version
- :exec-file gpr-process-parse-exec
- :face-table gpr-process-face-table
- :token-table gpr-process-token-table
- :repair-image gpr-process-repair-image
- )))
-
- (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)
-
-;; end of file
diff --git a/packages/ada-mode/gpr.wy b/packages/ada-mode/gpr.wy
index f7bf4d8..5fd7d3a 100644
--- a/packages/ada-mode/gpr.wy
+++ b/packages/ada-mode/gpr.wy
@@ -101,6 +101,7 @@
;; LR1 gives better error correction performance.
%elisp_face font-lock-function-name-face
+%elisp_face font-lock-keyword-face
%elisp_face nil
%mckenzie_cost_default 4 4 2 2
@@ -151,6 +152,7 @@ attribute_declaration
;; (info "(gprbuild_ug)Attributes")
attribute_prefix
: PROJECT
+ ;; not a keyword; no face
| name
;
@@ -294,7 +296,7 @@ project_extension
%((progn
(wisi-statement-action [1 statement-start 9 statement-end])
(wisi-name-action 2)
- (wisi-face-apply-action [2 nil font-lock-function-name-face 8 nil
font-lock-function-name-face])
+ (wisi-face-apply-action [1 nil font-lock-keyword-face 2 nil
font-lock-function-name-face 8 nil font-lock-function-name-face])
(wisi-indent-action [0 gpr-indent-broken 0 gpr-indent-broken 0
[gpr-indent gpr-indent] 0 0 0])))%
%((wisi-match-names 2 8))%
;
@@ -331,7 +333,9 @@ simple_project_declaration
%((progn
(wisi-statement-action [1 statement-start 7 statement-end])
(wisi-name-action 2)
- (wisi-face-apply-action [2 nil font-lock-function-name-face 6 nil
font-lock-function-name-face])
+ (wisi-face-apply-action [1 nil font-lock-keyword-face
+ 2 nil font-lock-function-name-face
+ 6 nil font-lock-function-name-face])
(wisi-indent-action [0 gpr-indent-broken 0 [gpr-indent gpr-indent] 0 0
0])))%
%((wisi-match-names 2 6))%
;
diff --git a/packages/ada-mode/gpr_process_actions.adb
b/packages/ada-mode/gpr_process_actions.adb
index f01ac6a..ddace40 100644
--- a/packages/ada-mode/gpr_process_actions.adb
+++ b/packages/ada-mode/gpr_process_actions.adb
@@ -55,7 +55,7 @@ package body Gpr_Process_Actions is
Statement_Action (Parse_Data, Tree, Nonterm, Tokens, ((1,
Statement_Start), (5, Statement_End)));
Name_Action (Parse_Data, Tree, Nonterm, Tokens, 2);
when Face =>
- Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, (1 => (2, 1,
0)));
+ Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, (1 => (2, 2,
0)));
when Indent =>
Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple,
(Int, 0))), (False, (Simple, (Int,
Gpr_Indent_Broken))), (False, (Simple, (Int, 0))), (False, (Simple,
(Int, Gpr_Indent_Broken))), (False,
@@ -76,7 +76,7 @@ package body Gpr_Process_Actions is
Statement_Action (Parse_Data, Tree, Nonterm, Tokens, ((1,
Statement_Start), (8, Statement_End)));
Name_Action (Parse_Data, Tree, Nonterm, Tokens, 2);
when Face =>
- Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, (1 => (2, 1,
0)));
+ Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, (1 => (2, 2,
0)));
when Indent =>
Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple,
(Int, 0))), (False, (Simple, (Int,
Gpr_Indent_Broken))), (False, (Simple, (Int, Gpr_Indent_Broken -
1))), (False, (Simple, (Int,
@@ -98,7 +98,7 @@ package body Gpr_Process_Actions is
Statement_Action (Parse_Data, Tree, Nonterm, Tokens, ((1,
Statement_Start), (10, Statement_End)));
Name_Action (Parse_Data, Tree, Nonterm, Tokens, 2);
when Face =>
- Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, (1 => (2, 1,
0)));
+ Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, (1 => (2, 2,
0)));
when Indent =>
Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple,
(Int, 0))), (False, (Simple, (Int,
Gpr_Indent_Broken))), (False, (Simple, (Int, Gpr_Indent_Broken -
1))), (False, (Simple, (Int,
@@ -212,7 +212,7 @@ package body Gpr_Process_Actions is
Statement_Action (Parse_Data, Tree, Nonterm, Tokens, ((1,
Statement_Start), (7, Statement_End)));
Name_Action (Parse_Data, Tree, Nonterm, Tokens, 2);
when Face =>
- Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, ((2, 1, 0), (6,
1, 0)));
+ Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, ((2, 2, 0), (6,
2, 0)));
when Indent =>
Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple,
(Int, 0))), (False, (Simple, (Int,
Gpr_Indent_Broken))), (False, (Simple, (Int, 0))), (True, (Simple,
(Int, Gpr_Indent)), (Simple, (Int,
@@ -245,7 +245,7 @@ package body Gpr_Process_Actions is
Statement_Action (Parse_Data, Tree, Nonterm, Tokens, ((1,
Statement_Start), (9, Statement_End)));
Name_Action (Parse_Data, Tree, Nonterm, Tokens, 2);
when Face =>
- Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, ((2, 1, 0), (8,
1, 0)));
+ Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, ((2, 2, 0), (8,
2, 0)));
when Indent =>
Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple,
(Int, 0))), (False, (Simple, (Int,
Gpr_Indent_Broken))), (False, (Simple, (Int, 0))), (False, (Simple,
(Int, Gpr_Indent_Broken))), (False,
@@ -278,7 +278,7 @@ package body Gpr_Process_Actions is
when Navigate =>
Statement_Action (Parse_Data, Tree, Nonterm, Tokens, ((1,
Statement_Start), (5, Statement_End)));
when Face =>
- Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, ((2, 1, 0), (4,
1, 0)));
+ Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, ((2, 2, 0), (4,
2, 0)));
when Indent =>
null;
end case;
@@ -297,7 +297,7 @@ package body Gpr_Process_Actions is
Statement_Action (Parse_Data, Tree, Nonterm, Tokens, ((1,
Statement_Start), (9, Statement_End)));
Name_Action (Parse_Data, Tree, Nonterm, Tokens, 2);
when Face =>
- Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, ((2, 1, 0), (8,
1, 0)));
+ Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, ((1, 2, 1), (2,
2, 0), (8, 2, 0)));
when Indent =>
Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple,
(Int, 0))), (False, (Simple, (Int,
Gpr_Indent_Broken))), (False, (Simple, (Int, 0))), (False, (Simple,
(Int, Gpr_Indent_Broken))), (False,
@@ -388,7 +388,7 @@ package body Gpr_Process_Actions is
Statement_Action (Parse_Data, Tree, Nonterm, Tokens, ((1,
Statement_Start), (7, Statement_End)));
Name_Action (Parse_Data, Tree, Nonterm, Tokens, 2);
when Face =>
- Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, ((2, 1, 0), (6,
1, 0)));
+ Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, ((1, 2, 1), (2,
2, 0), (6, 2, 0)));
when Indent =>
Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple,
(Int, 0))), (False, (Simple, (Int,
Gpr_Indent_Broken))), (False, (Simple, (Int, 0))), (True, (Simple,
(Int, Gpr_Indent)), (Simple, (Int,
diff --git a/packages/ada-mode/gpr_query.adb b/packages/ada-mode/gpr_query.adb
index 7a87141..344f4ff 100644
--- a/packages/ada-mode/gpr_query.adb
+++ b/packages/ada-mode/gpr_query.adb
@@ -3,9 +3,7 @@
-- Support Emacs Ada mode and gpr-query minor mode queries about
-- GNAT projects and cross reference data
--
--- requires gnatcoll 1.7w 20140330, gnat 7.2.1
---
--- Copyright (C) 2014-2018 Free Software Foundation All Rights Reserved.
+-- Copyright (C) 2014 - 2020 Free Software Foundation All Rights Reserved.
--
-- This program is free software; you can redistribute it and/or
-- modify it under terms of the GNU General Public License as
@@ -47,6 +45,8 @@ with GNATCOLL.Xref;
procedure Gpr_Query is
use GNATCOLL;
+ Version : constant String := "2";
+
Me : constant GNATCOLL.Traces.Trace_Handle := GNATCOLL.Traces.Create
("gpr_query");
Db_Error : exception;
@@ -70,6 +70,10 @@ procedure Gpr_Query is
type My_Xref_Database is new GNATCOLL.Xref.Xref_Database with null record;
-- Derived so we can override Image to output full paths
+ Short_File_Names : Boolean; -- set by each command that calls Image
+ -- Full_File_Names_Arg : constant String := "full_file_names";
+ Short_File_Names_Arg : constant String := "short_file_names";
+
overriding function Image (Self : My_Xref_Database; File :
GNATCOLL.VFS.Virtual_File) return String;
function Image (Self : GNATCOLL.Xref.Entity_Information) return String;
-- Return a display version of the argument
@@ -83,7 +87,8 @@ procedure Gpr_Query is
-- Subprogram specs for subprograms used before bodies
procedure Check_Arg_Count (Args : in GNATCOLL.Arg_Lists.Arg_List; Expected
: in Integer);
procedure Dump (Curs : in out GNATCOLL.Xref.Entities_Cursor'Class);
- procedure Dump (Refs : in out GNATCOLL.Xref.References_Cursor'Class);
+ procedure Dump (Refs : in out GNATCOLL.Xref.References_Cursor'Class;
Controlling_Type_Name : in String := "");
+ procedure Dump_Local (Refs : in out GNATCOLL.Xref.References_Cursor'Class;
Local_File_Name : in String);
-- Display the results of a query
procedure Put (Item : GNATCOLL.VFS.File_Array);
@@ -107,7 +112,9 @@ procedure Gpr_Query is
Entity : Entity_Information;
Comp : Entity_Information;
begin
- Check_Arg_Count (Args, 1);
+ Check_Arg_Count (Args, 2);
+
+ Short_File_Names := Nth_Arg (Args, 2) = Short_File_Names_Arg;
Entity := Get_Entity (Nth_Arg (Args, 1));
Comp := Compute (Xref, Entity);
@@ -140,7 +147,9 @@ procedure Gpr_Query is
Compute (Self, Entity, Cursor);
end Do_Compute;
begin
- Check_Arg_Count (Args, 1);
+ Check_Arg_Count (Args, 2);
+
+ Short_File_Names := Nth_Arg (Args, 2) = Short_File_Names_Arg;
Entity := Get_Entity (Nth_Arg (Args, 1));
@@ -167,6 +176,8 @@ procedure Gpr_Query is
procedure Process_Parent_Types is new Process_Command_Multiple
(GNATCOLL.Xref.Parent_Types);
procedure Process_Project_Path (Args : GNATCOLL.Arg_Lists.Arg_List);
procedure Process_Refs (Args : GNATCOLL.Arg_Lists.Arg_List);
+ procedure Process_Tree_Defs (Args : GNATCOLL.Arg_Lists.Arg_List);
+ procedure Process_Tree_Refs (Args : GNATCOLL.Arg_Lists.Arg_List);
procedure Process_Source_Dirs (Args : GNATCOLL.Arg_Lists.Arg_List);
type Command_Descr is record
@@ -195,17 +206,17 @@ procedure Gpr_Query is
-- queries
(new String'("overridden"),
- new String'("name:file:line:column"),
+ new String'("name:file:line:column {full_file_names |
short_file_names}"),
new String'("The entity that is overridden by the parameter"),
Process_Overridden'Access),
(new String'("overriding"),
- new String'("name:file:line:column"),
+ new String'("name:file:line:column {full_file_names |
short_file_names}"),
new String'("The entities that override the parameter"),
Process_Overriding'Access),
(new String'("parent_types"),
- new String'("name:file:line:column"),
+ new String'("name:file:line:column {full_file_names |
short_file_names}"),
new String'("The parent types of the entity."),
Process_Parent_Types'Access),
@@ -215,10 +226,22 @@ procedure Gpr_Query is
Process_Project_Path'Access),
(new String'("refs"),
- new String'("name:file:line:column"),
+ new String'("name:file:line:column {global | local_only}
{full_file_names | short_file_names}"),
new String'("All known references to the entity."),
Process_Refs'Access),
+ (new String'("tree_defs"),
+ new String'("name:file:line:column {full_file_names |
short_file_names}"),
+ new String'
+ ("All known references to the entity, and to parent/child types or
overridden/overriding operations."),
+ Process_Tree_Defs'Access),
+
+ (new String'("tree_refs"),
+ new String'("name:file:line:column {full_file_names |
short_file_names}"),
+ new String'
+ ("All known references to the entity, and to parent/child types or
overridden/overriding operations."),
+ Process_Tree_Refs'Access),
+
(new String'("source_dirs"),
null,
new String'("The project source directories, recursively."),
@@ -226,15 +249,16 @@ procedure Gpr_Query is
-- Parsed command line info
Cmdline : GNAT.Command_Line.Command_Line_Configuration;
+
+ ALI_Encoding : aliased GNAT.Strings.String_Access := new
String'("");
Commands_From_Switch : aliased GNAT.Strings.String_Access;
DB_Name : aliased GNAT.Strings.String_Access := new
String'("gpr_query.db");
Force_Refresh : aliased Boolean;
+ Gpr_Config_File : aliased GNAT.Strings.String_Access;
Nightly_DB_Name : aliased GNAT.Strings.String_Access;
- Show_Progress : aliased Boolean;
Project_Name : aliased GNAT.Strings.String_Access;
+ Show_Progress : aliased Boolean;
Traces_Config_File : aliased GNAT.Strings.String_Access;
- Gpr_Config_File : aliased GNAT.Strings.String_Access;
- ALI_Encoding : aliased GNAT.Strings.String_Access := new
String'("");
----------
-- Procedure bodies, alphabetical
@@ -272,7 +296,7 @@ procedure Gpr_Query is
end loop;
end Dump;
- procedure Dump (Refs : in out GNATCOLL.Xref.References_Cursor'Class)
+ procedure Dump (Refs : in out GNATCOLL.Xref.References_Cursor'Class;
Controlling_Type_Name : in String := "")
is
use GNATCOLL.Xref;
begin
@@ -280,12 +304,33 @@ procedure Gpr_Query is
declare
Ref : constant Entity_Reference := Refs.Element;
begin
- Ada.Text_IO.Put_Line (Xref.Image (Ref) & " (" & (+Ref.Kind) & ")");
+ Ada.Text_IO.Put_Line
+ (Xref.Image (Ref) & " (" &
+ (if Controlling_Type_Name'Length = 0
+ then ""
+ else Controlling_Type_Name & "; ") &
+ (+Ref.Kind) & ")");
end;
Next (Refs);
end loop;
end Dump;
+ procedure Dump_Local (Refs : in out GNATCOLL.Xref.References_Cursor'Class;
Local_File_Name : in String)
+ is
+ use GNATCOLL.Xref;
+ begin
+ while Has_Element (Refs) loop
+ declare
+ Ref : constant Entity_Reference := Refs.Element;
+ begin
+ if Local_File_Name = "" or else Local_File_Name =
Ref.File.Display_Base_Name then
+ Ada.Text_IO.Put_Line (Xref.Image (Ref) & " (" & (+Ref.Kind) &
")");
+ end if;
+ end;
+ Next (Refs);
+ end loop;
+ end Dump_Local;
+
function Get_Entity (Arg : String) return GNATCOLL.Xref.Entity_Information
is
use GNAT.Directory_Operations;
@@ -345,7 +390,11 @@ procedure Gpr_Query is
is
pragma Unreferenced (Self);
begin
- return File.Display_Full_Name;
+ if Short_File_Names then
+ return File.Display_Base_Name;
+ else
+ return File.Display_Full_Name;
+ end if;
end Image;
function Image (Self : GNATCOLL.Xref.Entity_Information) return String
@@ -448,6 +497,7 @@ procedure Gpr_Query is
pragma Unreferenced (Args);
Dirs : constant GNATCOLL.VFS.File_Array :=
GNATCOLL.Projects.Predefined_Project_Path (Env.all);
begin
+ Short_File_Names := False;
Put (Dirs);
end Process_Project_Path;
@@ -458,18 +508,347 @@ procedure Gpr_Query is
is
use GNATCOLL.Arg_Lists;
begin
- Check_Arg_Count (Args, 1);
+ Check_Arg_Count (Args, 3); -- entity, local/global, full/short
+
+ Short_File_Names := Nth_Arg (Args, 3) = Short_File_Names_Arg;
declare
use GNATCOLL.Xref;
Entity : constant Entity_Information := Get_Entity (Nth_Arg (Args,
1));
Refs : References_Cursor;
begin
- Xref.References (Entity, Cursor => Refs);
- Dump (Refs);
+ Xref.References (Entity, Refs);
+ if Nth_Arg (Args, 2) = "local_only" then
+ -- Xref doesn't let us get the full file name of Entity (sigh)
+ declare
+ use Ada.Strings.Fixed;
+ First : constant Integer := 1 + Index (Nth_Arg (Args,
1), ":");
+ Last : constant Integer := -1 + Index (Nth_Arg
(Args, 1), ":", First);
+ Local_File_Name : constant String := Nth_Arg (Args, 1) (First
.. Last);
+ begin
+ Dump_Local (Refs, Local_File_Name);
+ end;
+ else
+ Dump (Refs);
+ end if;
end;
end Process_Refs;
+ function Has_Op
+ (Entity : in GNATCOLL.Xref.Entity_Information;
+ Primitive_Op_Name : in String := "")
+ return Boolean
+ is
+ use GNATCOLL.Xref;
+ Ops : Entities_Cursor;
+ begin
+ Xref.Methods (Entity, Ops);
+ loop
+ exit when not Has_Element (Ops);
+ if Primitive_Op_Name = +Xref.Declaration (Element (Ops)).Name then
+ return True;
+ end if;
+ Next (Ops);
+ end loop;
+ return False;
+ end Has_Op;
+
+ function Root_Parent_Type
+ (Entity : in GNATCOLL.Xref.Entity_Information;
+ Primitive_Op_Name : in String := "")
+ return GNATCOLL.Xref.Entity_Information
+ is
+ use GNATCOLL.Xref;
+ Result : Entity_Information := Entity;
+ Parents : Entities_Cursor;
+ begin
+ loop
+ Xref.Parent_Types (Result, Parents);
+ -- There is more than one parent when the type inherits interfaces.
+ -- We assume the first parent is a non-interface (if there is one),
+ -- and ignore the rest.
+ exit when (not Parents.Has_Element) or else
+ (Primitive_Op_Name'Length > 0 and then not Has_Op (Parents.Element,
Primitive_Op_Name));
+ Result := Parents.Element;
+ end loop;
+ return Result;
+ end Root_Parent_Type;
+
+ procedure All_Child_Types
+ (Entity : in GNATCOLL.Xref.Entity_Information;
+ Cursor : in out GNATCOLL.Xref.Recursive_Entities_Cursor)
+ is begin
+ GNATCOLL.Xref.Recursive
+ (Self => Xref'Unchecked_Access,
+ Entity => Entity,
+ Compute => GNATCOLL.Xref.Child_Types'Access,
+ Cursor => Cursor);
+ end All_Child_Types;
+
+ function Controlling_Type (Entity : in GNATCOLL.Xref.Entity_Information)
return GNATCOLL.Xref.Entity_Information
+ is
+ use GNATCOLL.Xref;
+ -- Method_Of returns a derived type if the subprogram is not
+ -- overridden for the child; the type we want is the non-child; the
+ -- last item in Controlling_Types.
+ Types : Entities_Cursor;
+ Result : Entity_Information := No_Entity;
+ begin
+ Xref.Method_Of (Entity, Types);
+ loop
+ exit when not Has_Element (Types);
+ Result := Types.Element;
+ Next (Types);
+ end loop;
+ return Result;
+ end Controlling_Type;
+
+ procedure Dump_Decl (Decl : in GNATCOLL.Xref.Entity_Declaration;
Controlling_Type_Name : in String := "")
+ is begin
+ Ada.Text_IO.Put_Line
+ (Xref.Image (Decl.Location) & " (" &
+ (+Decl.Name) & " " &
+ (if Controlling_Type_Name'Length = 0
+ then ""
+ else Controlling_Type_Name & "; ") &
+ (+Decl.Kind) & ")");
+ end Dump_Decl;
+
+ procedure Dump_Ref (Ref : in GNATCOLL.Xref.Entity_Reference;
Controlling_Type_Name : in String := "")
+ is begin
+ Ada.Text_IO.Put_Line
+ (Xref.Image (Ref) & " (" &
+ (+Xref.Declaration (Ref.Entity).Name) & " " &
+ (if Controlling_Type_Name'Length = 0
+ then ""
+ else Controlling_Type_Name & "; ") &
+ (+Ref.Kind) & ")");
+ end Dump_Ref;
+
+ procedure Dump_Entity (Entity : in GNATCOLL.Xref.Entity_Information;
Controlling_Type_Name : in String := "")
+ is
+ use GNATCOLL.Xref;
+ Spec_Decl : constant Entity_Declaration := Xref.Declaration (Entity);
+ Body_Decls : References_Cursor;
+ begin
+ Xref.Bodies (Entity, Body_Decls);
+ if not Has_Element (Body_Decls) then
+ Dump_Decl (Spec_Decl);
+ else
+ declare
+ use all type GNATCOLL.VFS.Virtual_File;
+ First_Body_Ref : constant Entity_Reference := Body_Decls.Element;
+ begin
+ if First_Body_Ref.File = Spec_Decl.Location.File and
+ First_Body_Ref.Line = Spec_Decl.Location.Line and
+ First_Body_Ref.Column = Spec_Decl.Location.Column
+ then
+ Ada.Text_IO.Put_Line
+ (Xref.Image (First_Body_Ref) & " (" & (+Spec_Decl.Name) & " "
&
+ (if Controlling_Type_Name'Length = 0
+ then ""
+ else Controlling_Type_Name & "; ") &
+ (+Spec_Decl.Kind) & "/" & (+First_Body_Ref.Kind) & ")");
+ else
+ Dump_Decl (Spec_Decl, Controlling_Type_Name);
+ Dump_Ref (First_Body_Ref, Controlling_Type_Name);
+ end if;
+ end;
+
+ Next (Body_Decls);
+
+ loop
+ exit when not Has_Element (Body_Decls);
+ Dump_Ref (Body_Decls.Element, Controlling_Type_Name);
+ Next (Body_Decls);
+ end loop;
+ end if;
+ end Dump_Entity;
+
+ procedure Process_Tree_Defs (Args : GNATCOLL.Arg_Lists.Arg_List)
+ is
+ -- "tree_defs" <name:loc> {short_file_names | full_file_names}
+
+ use GNATCOLL.Arg_Lists;
+ use GNATCOLL.Xref;
+
+ Orig_Entity : constant Entity_Information := Get_Entity (Nth_Arg (Args,
1));
+ Orig_Decl : constant Entity_Declaration := Xref.Declaration
(Orig_Entity);
+ Root_Parent : Entity_Information;
+
+ procedure Dump_Method
+ (Type_Entity : in GNATCOLL.Xref.Entity_Information;
+ Primitive_Op_Name : in String)
+ is
+ Type_Name : constant String := +Xref.Declaration (Type_Entity).Name;
+ Ops : Entities_Cursor;
+ begin
+ Xref.Methods (Type_Entity, Ops);
+ loop
+ exit when not Has_Element (Ops);
+ declare
+ Method_Name : constant String := +Xref.Declaration (Element
(Ops)).Name;
+ begin
+ if Primitive_Op_Name = Method_Name then
+ -- IMPROVEME: if the method is inherited but not
overridden, use the
+ -- type location.
+ Dump_Entity (Element (Ops), Type_Name);
+ return;
+ end if;
+ end;
+ Next (Ops);
+ end loop;
+ end Dump_Method;
+
+ procedure Dump_Entities (Entities : in out Recursive_Entities_Cursor)
+ is begin
+ loop
+ exit when not Has_Element (Entities);
+ if Orig_Decl.Flags.Is_Subprogram then
+ Dump_Method (Entities.Element, +Orig_Decl.Name);
+ else
+ Dump_Entity (Entities.Element);
+ end if;
+ Next (Entities);
+ end loop;
+ end Dump_Entities;
+
+ begin
+ Short_File_Names := Nth_Arg (Args, 2) = Short_File_Names_Arg;
+
+ if Orig_Decl.Flags.Is_Type then
+ -- It is tempting to find the highest ancestor type here, then show
+ -- all types derived from that. But in Ada, that root ancestor is
+ -- often Ada.Finalization.[Limited_]Controlled (or some similar root
+ -- type), so the tree is much larger than we really want. So we just
+ -- show all children of the given type; the user can then climb the
+ -- tree if they want to enlarge it. This also allows the user to
+ -- choose which anscestor to examine when there is more than one,
+ -- with interfaces.
+ Root_Parent := Orig_Entity;
+
+ elsif Orig_Decl.Flags.Is_Subprogram then
+ declare
+ Controlling : constant Entity_Information := Controlling_Type
(Orig_Entity);
+ begin
+ if Controlling = No_Entity then
+ -- Not a primitive subprogram
+ Dump_Entity (Orig_Entity);
+ return;
+ else
+ -- Here we find the highest ancestor type that has this method.
+ Root_Parent := Root_Parent_Type (Controlling, Primitive_Op_Name
=> +Orig_Decl.Name);
+ end if;
+ end;
+ else
+ -- Something else (variable, package, ...)
+ Dump_Decl (Orig_Decl);
+ return;
+ end if;
+
+ declare
+ Child_Types : Recursive_Entities_Cursor;
+ begin
+ -- "Child_Types" includes generic formal parameters (ie
+ -- gen_run_wisi_lr_parse.ads Parse_Data_Type) in addition to the
+ -- actual parameters.
+ All_Child_Types (Root_Parent, Child_Types);
+ if Orig_Decl.Flags.Is_Type then
+ Dump_Entity (Root_Parent);
+ else
+ Dump_Method (Root_Parent, +Orig_Decl.Name);
+ end if;
+ Dump_Entities (Child_Types);
+ end;
+ end Process_Tree_Defs;
+
+ procedure Process_Tree_Refs (Args : GNATCOLL.Arg_Lists.Arg_List)
+ is
+ -- "tree_refs" <name:loc> {short_file_names | full_file_names}
+
+ use GNATCOLL.Arg_Lists;
+ use GNATCOLL.Xref;
+ Orig_Entity : constant Entity_Information := Get_Entity (Nth_Arg (Args,
1));
+ Orig_Decl : constant Entity_Declaration := Xref.Declaration
(Orig_Entity);
+ Root_Parent : Entity_Information;
+
+ procedure Dump_Type (Type_Entity : in Entity_Information)
+ is
+ Methods : Entities_Cursor;
+ begin
+ if Orig_Decl.Flags.Is_Subprogram then
+ Xref.Methods (Type_Entity, Methods);
+ loop
+ exit when not Has_Element (Methods);
+ declare
+ Method_Name : constant String := +Xref.Declaration
(Methods.Element).Name;
+ Refs : References_Cursor;
+ begin
+ if Method_Name = +Orig_Decl.Name then
+ Xref.References (Methods.Element, Refs);
+ Dump (Refs, +Xref.Declaration (Type_Entity).Name);
+ end if;
+ end;
+ Next (Methods);
+ end loop;
+ else
+ Dump_Entity (Type_Entity);
+ end if;
+ end Dump_Type;
+
+ procedure Dump_Types (Types : in out Recursive_Entities_Cursor)
+ is begin
+ loop
+ exit when not Has_Element (Types);
+ Dump_Type (Types.Element);
+ Next (Types);
+ end loop;
+ end Dump_Types;
+ begin
+ Short_File_Names := Nth_Arg (Args, 2) = Short_File_Names_Arg;
+
+ if Orig_Decl.Flags.Is_Type then
+ -- See comment in Process_Tree_Defs
+ Root_Parent := Orig_Entity;
+
+ elsif Orig_Decl.Flags.Is_Subprogram then
+ declare
+ Controlling : constant Entity_Information := Controlling_Type
(Orig_Entity);
+ begin
+ if Controlling = No_Entity then
+ -- Not a primitive subprogram
+ declare
+ Refs : References_Cursor;
+ begin
+ Xref.References (Orig_Entity, Refs);
+ Dump (Refs);
+ return;
+ end;
+ else
+ Root_Parent := Root_Parent_Type (Controlling, Primitive_Op_Name
=> +Orig_Decl.Name);
+ end if;
+ end;
+ else
+ -- A variable
+ declare
+ Refs : References_Cursor;
+ begin
+ Xref.References (Orig_Entity, Refs);
+ Dump (Refs);
+ return;
+ end;
+ end if;
+
+ declare
+ Child_Types : Recursive_Entities_Cursor;
+ begin
+ All_Child_Types (Root_Parent, Child_Types);
+
+ Dump_Type (Root_Parent);
+ Dump_Types (Child_Types);
+ end;
+ end Process_Tree_Refs;
+
procedure Process_Source_Dirs (Args : GNATCOLL.Arg_Lists.Arg_List)
is
pragma Unreferenced (Args);
@@ -481,6 +860,7 @@ procedure Gpr_Query is
Recursive => True) &
Predefined_Source_Path (Env.all);
begin
+ Short_File_Names := False;
Put (Dirs);
end Process_Source_Dirs;
@@ -494,6 +874,8 @@ procedure Gpr_Query is
end Put;
begin
+ Ada.Text_IO.Put_Line ("version: " & Version);
+
declare
use GNAT.Command_Line;
begin
@@ -600,15 +982,15 @@ begin
Gpr_Project_Path : constant String :=
(if Exists ("GPR_PROJECT_PATH") then Ada.Directories.Current_Directory
&
- GNAT.OS_Lib.Path_Separator &
- Value ("GPR_PROJECT_PATH")
+ GNAT.OS_Lib.Path_Separator &
+ Value ("GPR_PROJECT_PATH")
else Ada.Directories.Current_Directory);
Path : constant Virtual_File := -- must be an absolute file name
(if Is_Absolute_Path (+Project_Name.all) then
- Create_From_UTF8 (Project_Name.all, Normalize => True)
+ Create_From_UTF8 (Project_Name.all, Normalize => True)
else
- Locate_Regular_File (+Project_Name.all, From_Path
(+Gpr_Project_Path)));
+ Locate_Regular_File (+Project_Name.all, From_Path
(+Gpr_Project_Path)));
begin
if not Path.Is_Regular_File then
Put (Project_Name.all & ": not found on path " & Gpr_Project_Path);
@@ -616,6 +998,7 @@ begin
return;
end if;
+ GNATCOLL.Traces.Trace (Me, "project path " & Gpr_Project_Path);
GNATCOLL.Traces.Trace (Me, "using project file " & (+Path.Full_Name));
if Show_Progress then
diff --git a/packages/ada-mode/gpr_query.gpr.gp
b/packages/ada-mode/gpr_query.gpr.gp
deleted file mode 100644
index dce6ce2..0000000
--- a/packages/ada-mode/gpr_query.gpr.gp
+++ /dev/null
@@ -1,73 +0,0 @@
--- Abstract :
---
--- build gpr_query
---
--- Copyright (C) 2014 Free Software Foundation, Inc.
---
--- This program is free software; you can redistribute it and/or
--- modify it under terms of the GNU General Public License as
--- 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
--- distributed with this program; see file COPYING. If not, write to
--- the Free Software Foundation, 51 Franklin Street, Suite 500, Boston,
--- MA 02110-1335, USA.
-
-with "gnatcoll";
-with "gnatcoll_sqlite";
-#if HAVE_GNATCOLL_XREF="yes"
-with "gnatcoll_xref";
-#end if;
-with "gnat_util";
-project Gpr_query is
- for Main use ("gpr_query.adb");
-
- for Source_Dirs use (".");
-
- for Object_Dir use "obj";
-
- for Exec_Dir use ".";
-
- type Build_Type is ("Debug", "Normal");
- Build : Build_Type := External ("Gpr_Query_Build", "Normal");
-
- for Languages use ("Ada");
-
- package Compiler is
-
- Common_Switches :=
- ("-g",
- "-gnata", -- assertions
- "-gnatfoqQ",
- "-gnatVa", -- validity checks
- "-gnaty3abcefhiklM120nOprtx",
- "-gnateE", -- extra info in exceptions
- "-gnatwaBCeJL",
- "-fstack-check",
- "-gnat12");
-
- case Build is
- when "Debug" =>
- for Default_Switches ("Ada") use Common_Switches & ("-O0");
- when "Normal" =>
- -- WORKAROUND (GNAT 7.2.1): adding -gnatn here gives errors about
missing sources in installed gnatcoll.
- for Default_Switches ("Ada") use Common_Switches & ("-O2");
- end case;
- end Compiler;
-
- package Linker is
- for Default_Switches ("Ada") use ("-lpthread");
- end Linker;
-
- package Binder is
- for default_switches ("Ada") use ("-E"); -- symbolic traceback
- end Binder;
-
- package Install is
- for Mode use "usage";
- end Install;
-
-end Gpr_query;
diff --git a/packages/ada-mode/gpr_re2c.c b/packages/ada-mode/gpr_re2c.c
index 107372e..3ed8680 100644
--- a/packages/ada-mode/gpr_re2c.c
+++ b/packages/ada-mode/gpr_re2c.c
@@ -55,7 +55,7 @@ wisi_lexer* gpr_new_lexer
result->buffer_last = input + length - 1;
result->cursor = input;
result->byte_token_start = input;
- result->char_pos = 1;
+ result->char_pos = 1; /* match WisiToken.Buffer_Region */
result->char_token_start = 1;
result->line = (*result->cursor == 0x0A) ? 2 : 1;
result->line_token_start = result->line;
@@ -93,16 +93,22 @@ static void debug(wisi_lexer* lexer, int state, unsigned
char ch)
#define YYPEEK() (lexer->cursor <= lexer->buffer_last) ? *lexer->cursor : 4
-#define DO_COUNT ((*lexer->cursor & 0xC0) != 0xC0) && (*lexer->cursor != 0x0D)
-
static void skip(wisi_lexer* lexer)
{
if (lexer->cursor <= lexer->buffer_last)
- {
++lexer->cursor;
- if (DO_COUNT) ++lexer->char_pos;
- if (lexer->cursor <= lexer->buffer_last)
- if (*lexer->cursor == 0x0A) ++lexer->line;
+ if (lexer->cursor <= lexer->buffer_last)
+ {
+ /* UFT-8 encoding: https://en.wikipedia.org/wiki/UTF-8#Description */
+ if (*lexer->cursor == 0x0A && lexer->cursor > lexer->buffer &&
*(lexer->cursor - 1) == 0x0D)
+ {/* second byte of DOS line ending */
+ }
+ else if ((*lexer->cursor & 0x80) == 0x80 && (*lexer->cursor & 0xC0) !=
0xC0)
+ {/* byte 2, 3 or 4 of multi-byte UTF-8 char */
+ }
+ else
+ ++lexer->char_pos;
+ if (*lexer->cursor == 0x0A) ++lexer->line;
}
}
#define YYSKIP() skip(lexer)
@@ -143,7 +149,7 @@ int gpr_next_token
while (*id == -1 && status == 0)
{
-#line 147 "../gpr_re2c.c"
+#line 153 "../gpr_re2c.c"
{
YYCTYPE yych;
unsigned int yyaccept = 0;
@@ -287,21 +293,21 @@ yy2:
YYSKIP ();
yy3:
YYDEBUG(3, YYPEEK ());
-#line 235 "../gpr.re2c"
+#line 241 "../gpr.re2c"
{status = ERROR_unrecognized_character; continue;}
-#line 293 "../gpr_re2c.c"
+#line 299 "../gpr_re2c.c"
yy4:
YYDEBUG(4, YYPEEK ());
YYSKIP ();
YYDEBUG(5, YYPEEK ());
-#line 233 "../gpr.re2c"
+#line 239 "../gpr.re2c"
{*id = 39; continue;}
-#line 300 "../gpr_re2c.c"
+#line 306 "../gpr_re2c.c"
yy6:
YYDEBUG(6, YYPEEK ());
YYSKIP ();
YYDEBUG(7, YYPEEK ());
-#line 188 "../gpr.re2c"
+#line 194 "../gpr.re2c"
{ lexer->byte_token_start = lexer->cursor;
lexer->char_token_start = lexer->char_pos;
if (*lexer->cursor == 0x0A)
@@ -309,14 +315,14 @@ yy6:
else
lexer->line_token_start = lexer->line;
continue; }
-#line 313 "../gpr_re2c.c"
+#line 319 "../gpr_re2c.c"
yy8:
YYDEBUG(8, YYPEEK ());
YYSKIP ();
YYDEBUG(9, YYPEEK ());
-#line 195 "../gpr.re2c"
+#line 201 "../gpr.re2c"
{*id = 1; continue;}
-#line 320 "../gpr_re2c.c"
+#line 326 "../gpr_re2c.c"
yy10:
YYDEBUG(10, YYPEEK ());
YYSKIP ();
@@ -485,37 +491,37 @@ yy12:
YYDEBUG(12, YYPEEK ());
YYSKIP ();
YYDEBUG(13, YYPEEK ());
-#line 221 "../gpr.re2c"
+#line 227 "../gpr.re2c"
{*id = 27; continue;}
-#line 491 "../gpr_re2c.c"
+#line 497 "../gpr_re2c.c"
yy14:
YYDEBUG(14, YYPEEK ());
YYSKIP ();
YYDEBUG(15, YYPEEK ());
-#line 227 "../gpr.re2c"
+#line 233 "../gpr.re2c"
{*id = 33; continue;}
-#line 498 "../gpr_re2c.c"
+#line 504 "../gpr_re2c.c"
yy16:
YYDEBUG(16, YYPEEK ());
YYSKIP ();
YYDEBUG(17, YYPEEK ());
-#line 208 "../gpr.re2c"
+#line 214 "../gpr.re2c"
{*id = 14; continue;}
-#line 505 "../gpr_re2c.c"
+#line 511 "../gpr_re2c.c"
yy18:
YYDEBUG(18, YYPEEK ());
YYSKIP ();
YYDEBUG(19, YYPEEK ());
-#line 215 "../gpr.re2c"
+#line 221 "../gpr.re2c"
{*id = 21; continue;}
-#line 512 "../gpr_re2c.c"
+#line 518 "../gpr_re2c.c"
yy20:
YYDEBUG(20, YYPEEK ());
YYSKIP ();
YYDEBUG(21, YYPEEK ());
-#line 224 "../gpr.re2c"
+#line 230 "../gpr.re2c"
{*id = 30; continue;}
-#line 519 "../gpr_re2c.c"
+#line 525 "../gpr_re2c.c"
yy22:
YYDEBUG(22, YYPEEK ());
YYSKIP ();
@@ -528,9 +534,9 @@ yy23:
YYDEBUG(23, YYPEEK ());
YYSKIP ();
YYDEBUG(24, YYPEEK ());
-#line 225 "../gpr.re2c"
+#line 231 "../gpr.re2c"
{*id = 31; continue;}
-#line 534 "../gpr_re2c.c"
+#line 540 "../gpr_re2c.c"
yy25:
YYDEBUG(25, YYPEEK ());
YYSKIP ();
@@ -551,9 +557,9 @@ yy25:
}
yy27:
YYDEBUG(27, YYPEEK ());
-#line 230 "../gpr.re2c"
+#line 236 "../gpr.re2c"
{*id = 36; continue;}
-#line 557 "../gpr_re2c.c"
+#line 563 "../gpr_re2c.c"
yy28:
YYDEBUG(28, YYPEEK ());
YYSKIP ();
@@ -564,16 +570,16 @@ yy28:
}
yy29:
YYDEBUG(29, YYPEEK ());
-#line 222 "../gpr.re2c"
+#line 228 "../gpr.re2c"
{*id = 28; continue;}
-#line 570 "../gpr_re2c.c"
+#line 576 "../gpr_re2c.c"
yy30:
YYDEBUG(30, YYPEEK ());
YYSKIP ();
YYDEBUG(31, YYPEEK ());
-#line 228 "../gpr.re2c"
+#line 234 "../gpr.re2c"
{*id = 34; continue;}
-#line 577 "../gpr_re2c.c"
+#line 583 "../gpr_re2c.c"
yy32:
YYDEBUG(32, YYPEEK ());
YYSKIP ();
@@ -599,9 +605,9 @@ yy33:
}
yy34:
YYDEBUG(34, YYPEEK ());
-#line 231 "../gpr.re2c"
+#line 237 "../gpr.re2c"
{*id = 37; continue;}
-#line 605 "../gpr_re2c.c"
+#line 611 "../gpr_re2c.c"
yy35:
YYDEBUG(35, YYPEEK ());
yyaccept = 1;
@@ -882,9 +888,9 @@ yy50:
YYDEBUG(50, YYPEEK ());
YYSKIP ();
YYDEBUG(51, YYPEEK ());
-#line 229 "../gpr.re2c"
+#line 235 "../gpr.re2c"
{*id = 35; continue;}
-#line 888 "../gpr_re2c.c"
+#line 894 "../gpr_re2c.c"
yy52:
YYDEBUG(52, YYPEEK ());
YYSKIP ();
@@ -1424,9 +1430,9 @@ yy61:
}
yy62:
YYDEBUG(62, YYPEEK ());
-#line 232 "../gpr.re2c"
+#line 238 "../gpr.re2c"
{*id = 38; continue;}
-#line 1430 "../gpr_re2c.c"
+#line 1436 "../gpr_re2c.c"
yy63:
YYDEBUG(63, YYPEEK ());
YYSKIP ();
@@ -1947,23 +1953,23 @@ yy69:
}
yy71:
YYDEBUG(71, YYPEEK ());
-#line 196 "../gpr.re2c"
+#line 202 "../gpr.re2c"
{*id = 2; continue;}
-#line 1953 "../gpr_re2c.c"
+#line 1959 "../gpr_re2c.c"
yy72:
YYDEBUG(72, YYPEEK ());
YYSKIP ();
YYDEBUG(73, YYPEEK ());
-#line 223 "../gpr.re2c"
+#line 229 "../gpr.re2c"
{*id = 29; continue;}
-#line 1960 "../gpr_re2c.c"
+#line 1966 "../gpr_re2c.c"
yy74:
YYDEBUG(74, YYPEEK ());
YYSKIP ();
YYDEBUG(75, YYPEEK ());
-#line 226 "../gpr.re2c"
+#line 232 "../gpr.re2c"
{*id = 32; continue;}
-#line 1967 "../gpr_re2c.c"
+#line 1973 "../gpr_re2c.c"
yy76:
YYDEBUG(76, YYPEEK ());
yyaccept = 1;
@@ -2111,9 +2117,9 @@ yy78:
}
yy79:
YYDEBUG(79, YYPEEK ());
-#line 198 "../gpr.re2c"
+#line 204 "../gpr.re2c"
{*id = 4; continue;}
-#line 2117 "../gpr_re2c.c"
+#line 2123 "../gpr_re2c.c"
yy80:
YYDEBUG(80, YYPEEK ());
YYSKIP ();
@@ -2624,9 +2630,9 @@ yy91:
}
yy92:
YYDEBUG(92, YYPEEK ());
-#line 207 "../gpr.re2c"
+#line 213 "../gpr.re2c"
{*id = 13; continue;}
-#line 2630 "../gpr_re2c.c"
+#line 2636 "../gpr_re2c.c"
yy93:
YYDEBUG(93, YYPEEK ());
yyaccept = 1;
@@ -3247,9 +3253,9 @@ yy114:
}
yy115:
YYDEBUG(115, YYPEEK ());
-#line 202 "../gpr.re2c"
+#line 208 "../gpr.re2c"
{*id = 8; continue;}
-#line 3253 "../gpr_re2c.c"
+#line 3259 "../gpr_re2c.c"
yy116:
YYDEBUG(116, YYPEEK ());
yyaccept = 1;
@@ -3386,9 +3392,9 @@ yy117:
}
yy118:
YYDEBUG(118, YYPEEK ());
-#line 206 "../gpr.re2c"
+#line 212 "../gpr.re2c"
{*id = 12; continue;}
-#line 3392 "../gpr_re2c.c"
+#line 3398 "../gpr_re2c.c"
yy119:
YYDEBUG(119, YYPEEK ());
yyaccept = 1;
@@ -3602,9 +3608,9 @@ yy127:
}
yy128:
YYDEBUG(128, YYPEEK ());
-#line 218 "../gpr.re2c"
+#line 224 "../gpr.re2c"
{*id = 24; continue;}
-#line 3608 "../gpr_re2c.c"
+#line 3614 "../gpr_re2c.c"
yy129:
YYDEBUG(129, YYPEEK ());
yyaccept = 1;
@@ -3774,9 +3780,9 @@ yy133:
}
yy134:
YYDEBUG(134, YYPEEK ());
-#line 200 "../gpr.re2c"
+#line 206 "../gpr.re2c"
{*id = 6; continue;}
-#line 3780 "../gpr_re2c.c"
+#line 3786 "../gpr_re2c.c"
yy135:
YYDEBUG(135, YYPEEK ());
yyaccept = 1;
@@ -3937,9 +3943,9 @@ yy138:
}
yy139:
YYDEBUG(139, YYPEEK ());
-#line 210 "../gpr.re2c"
+#line 216 "../gpr.re2c"
{*id = 16; continue;}
-#line 3943 "../gpr_re2c.c"
+#line 3949 "../gpr_re2c.c"
yy140:
YYDEBUG(140, YYPEEK ());
yyaccept = 1;
@@ -4120,9 +4126,9 @@ yy145:
}
yy146:
YYDEBUG(146, YYPEEK ());
-#line 217 "../gpr.re2c"
+#line 223 "../gpr.re2c"
{*id = 23; continue;}
-#line 4126 "../gpr_re2c.c"
+#line 4132 "../gpr_re2c.c"
yy147:
YYDEBUG(147, YYPEEK ());
yyaccept = 12;
@@ -4248,9 +4254,9 @@ yy147:
}
yy148:
YYDEBUG(148, YYPEEK ());
-#line 219 "../gpr.re2c"
+#line 225 "../gpr.re2c"
{*id = 25; continue;}
-#line 4254 "../gpr_re2c.c"
+#line 4260 "../gpr_re2c.c"
yy149:
YYDEBUG(149, YYPEEK ());
yyaccept = 13;
@@ -4376,9 +4382,9 @@ yy149:
}
yy150:
YYDEBUG(150, YYPEEK ());
-#line 220 "../gpr.re2c"
+#line 226 "../gpr.re2c"
{*id = 26; continue;}
-#line 4382 "../gpr_re2c.c"
+#line 4388 "../gpr_re2c.c"
yy151:
YYDEBUG(151, YYPEEK ());
yyaccept = 1;
@@ -4691,9 +4697,9 @@ yy168:
}
yy169:
YYDEBUG(169, YYPEEK ());
-#line 211 "../gpr.re2c"
+#line 217 "../gpr.re2c"
{*id = 17; continue;}
-#line 4697 "../gpr_re2c.c"
+#line 4703 "../gpr_re2c.c"
yy170:
YYDEBUG(170, YYPEEK ());
yyaccept = 1;
@@ -4896,9 +4902,9 @@ yy177:
}
yy178:
YYDEBUG(178, YYPEEK ());
-#line 203 "../gpr.re2c"
+#line 209 "../gpr.re2c"
{*id = 9; continue;}
-#line 4902 "../gpr_re2c.c"
+#line 4908 "../gpr_re2c.c"
yy179:
YYDEBUG(179, YYPEEK ());
yyaccept = 1;
@@ -5035,9 +5041,9 @@ yy180:
}
yy181:
YYDEBUG(181, YYPEEK ());
-#line 209 "../gpr.re2c"
+#line 215 "../gpr.re2c"
{*id = 15; continue;}
-#line 5041 "../gpr_re2c.c"
+#line 5047 "../gpr_re2c.c"
yy182:
YYDEBUG(182, YYPEEK ());
yyaccept = 17;
@@ -5163,9 +5169,9 @@ yy182:
}
yy183:
YYDEBUG(183, YYPEEK ());
-#line 212 "../gpr.re2c"
+#line 218 "../gpr.re2c"
{*id = 18; continue;}
-#line 5169 "../gpr_re2c.c"
+#line 5175 "../gpr_re2c.c"
yy184:
YYDEBUG(184, YYPEEK ());
yyaccept = 18;
@@ -5291,9 +5297,9 @@ yy184:
}
yy185:
YYDEBUG(185, YYPEEK ());
-#line 213 "../gpr.re2c"
+#line 219 "../gpr.re2c"
{*id = 19; continue;}
-#line 5297 "../gpr_re2c.c"
+#line 5303 "../gpr_re2c.c"
yy186:
YYDEBUG(186, YYPEEK ());
yyaccept = 19;
@@ -5419,9 +5425,9 @@ yy186:
}
yy187:
YYDEBUG(187, YYPEEK ());
-#line 214 "../gpr.re2c"
+#line 220 "../gpr.re2c"
{*id = 20; continue;}
-#line 5425 "../gpr_re2c.c"
+#line 5431 "../gpr_re2c.c"
yy188:
YYDEBUG(188, YYPEEK ());
yyaccept = 1;
@@ -5558,9 +5564,9 @@ yy189:
}
yy190:
YYDEBUG(190, YYPEEK ());
-#line 197 "../gpr.re2c"
+#line 203 "../gpr.re2c"
{*id = 3; continue;}
-#line 5564 "../gpr_re2c.c"
+#line 5570 "../gpr_re2c.c"
yy191:
YYDEBUG(191, YYPEEK ());
yyaccept = 1;
@@ -5708,9 +5714,9 @@ yy193:
}
yy194:
YYDEBUG(194, YYPEEK ());
-#line 204 "../gpr.re2c"
+#line 210 "../gpr.re2c"
{*id = 10; continue;}
-#line 5714 "../gpr_re2c.c"
+#line 5720 "../gpr_re2c.c"
yy195:
YYDEBUG(195, YYPEEK ());
yyaccept = 22;
@@ -5836,9 +5842,9 @@ yy195:
}
yy196:
YYDEBUG(196, YYPEEK ());
-#line 216 "../gpr.re2c"
+#line 222 "../gpr.re2c"
{*id = 22; continue;}
-#line 5842 "../gpr_re2c.c"
+#line 5848 "../gpr_re2c.c"
yy197:
YYDEBUG(197, YYPEEK ());
yyaccept = 23;
@@ -5964,9 +5970,9 @@ yy197:
}
yy198:
YYDEBUG(198, YYPEEK ());
-#line 199 "../gpr.re2c"
+#line 205 "../gpr.re2c"
{*id = 5; continue;}
-#line 5970 "../gpr_re2c.c"
+#line 5976 "../gpr_re2c.c"
yy199:
YYDEBUG(199, YYPEEK ());
yyaccept = 1;
@@ -6179,9 +6185,9 @@ yy207:
}
yy208:
YYDEBUG(208, YYPEEK ());
-#line 201 "../gpr.re2c"
+#line 207 "../gpr.re2c"
{*id = 7; continue;}
-#line 6185 "../gpr_re2c.c"
+#line 6191 "../gpr_re2c.c"
yy209:
YYDEBUG(209, YYPEEK ());
yyaccept = 1;
@@ -6340,20 +6346,18 @@ yy212:
}
yy213:
YYDEBUG(213, YYPEEK ());
-#line 205 "../gpr.re2c"
+#line 211 "../gpr.re2c"
{*id = 11; continue;}
-#line 6346 "../gpr_re2c.c"
+#line 6352 "../gpr_re2c.c"
}
-#line 236 "../gpr.re2c"
+#line 242 "../gpr.re2c"
- }
+ }
+ /* lexer->cursor and lexer ->char_pos are one char past end of token */
*byte_position = lexer->byte_token_start - lexer->buffer + 1;
*byte_length = lexer->cursor - lexer->byte_token_start;
*char_position = lexer->char_token_start;
- if (DO_COUNT)
- *char_length = lexer->char_pos - lexer->char_token_start;
- else
- *char_length = lexer->char_pos - lexer->char_token_start + 1;
- *line_start = lexer->line_token_start;
+ *char_length = lexer->char_pos - lexer->char_token_start;
+ *line_start = lexer->line_token_start;
return status;
}
diff --git a/packages/ada-mode/install.sh b/packages/ada-mode/install.sh
new file mode 100755
index 0000000..20b7237
--- /dev/null
+++ b/packages/ada-mode/install.sh
@@ -0,0 +1,15 @@
+#!/bin/sh
+# Install executables for Ada mode.
+#
+# See build.sh for build (must be run before install).
+
+# $1 : optional --prefix=<dir>
+#
+# If you don't have write permission in the GNAT installation
+# directory, you need to use --prefix=<dir>, or run with root priviledges.
+
+export GPR_PROJECT_PATH="../wisi-3.0.1"
+
+gprinstall -f -p -P ada_mode_wisi_parse.gpr --install-name=ada_mode_wisi_parse
$1
+
+# end of file.
diff --git a/packages/ada-mode/wisi-ada.adb b/packages/ada-mode/wisi-ada.adb
index e73b2da..f72ff1c 100644
--- a/packages/ada-mode/wisi-ada.adb
+++ b/packages/ada-mode/wisi-ada.adb
@@ -2,7 +2,7 @@
--
-- see spec.
--
--- Copyright (C) 2017 - 2019 Free Software Foundation, Inc.
+-- Copyright (C) 2017 - 2020 Free Software Foundation, Inc.
--
-- This library is free software; you can redistribute it and/or modify it
-- under terms of the GNU General Public License as published by the Free
@@ -34,8 +34,6 @@ package body Wisi.Ada is
is
use Ada_Process_Actions;
begin
- -- [1] ada-wisi-elisp-parse--indent-record-1.
-
if Anchor_Token.Byte_Region = Null_Buffer_Region or
Record_Token.Byte_Region = Null_Buffer_Region or
Indenting_Token.Byte_Region = Null_Buffer_Region
@@ -49,8 +47,26 @@ package body Wisi.Ada is
(Data, Anchor_Token.Line, Record_Token.Last_Line
(Indenting_Comment), Ada_Indent_Record_Rel_Type,
Accumulate => True);
+ elsif Indenting_Comment and Indenting_Token.ID = +WITH_ID then
+ -- comment before 'record'. test/ada_mode-nominal-child.ads
Child_Type_1
+ return Indent_Anchored_2
+ (Data, Anchor_Token.Line, Indenting_Token.Last_Line
(Indenting_Comment), Ada_Indent_Record_Rel_Type,
+ Accumulate => True);
+
+ elsif Indenting_Comment and Indenting_Token.ID = +IS_ID then
+ -- comment after 'is'
+ if Record_Token.ID = +RECORD_ID then
+ -- before 'record'. test/ada_mode-nominal.ads Record_Type_1
+ return Indent_Anchored_2
+ (Data, Anchor_Token.Line, Indenting_Token.Last_Line
(Indenting_Comment), Ada_Indent_Record_Rel_Type,
+ Accumulate => True);
+ else
+ -- not before 'record'. test/ada_mode-nominal-child.ads
Child_Type_1
+ return (Simple, (Int, Offset));
+ end if;
+
else
- -- Indenting comment, component or 'end'
+ -- Indenting other comment, component or 'end'
--
-- Ensure 'record' line is anchored.
if not (Data.Indents (Record_Token.Line).Label = Anchored or
@@ -70,7 +86,6 @@ package body Wisi.Ada is
end if;
end if;
- -- from [2] wisi-elisp-parse--anchored-1
return Indent_Anchored_2
(Data,
Anchor_Line => Anchor_Token.Line,
@@ -701,12 +716,15 @@ package body Wisi.Ada is
-- In our grammar, 'aggregate' can be an Ada aggregate, or a
-- parenthesized expression.
--
- -- We always want an 'aggregate' to be indented by
- -- ada-indent-broken. However, in some places in the grammar,
- -- 'aggregate' is indented by ada-indent. The following checks for
- -- those places, and returns a correction value.
-
- Expression : constant Syntax_Trees.Node_Index := Tree.Find_Ancestor
(Tree_Indenting, +expression_opt_ID);
+ -- We always want an 'aggregate' to be indented by ada-indent-broken.
+ -- However, in some places in the grammar, 'aggregate' is indented by
+ -- ada-indent. The following checks for those places, and returns a
+ -- correction value. The aggregate may be nested inside a conidtional
+ -- expression, so we search for 'name' as well; see
+ -- test/ada_mode-conditional_expressions-more_1.adb.
+
+ Expression : constant Syntax_Trees.Node_Index := Tree.Find_Ancestor
+ (Tree_Indenting, (+expression_opt_ID, +name_ID));
begin
if Expression = Syntax_Trees.Invalid_Node_Index or else
Tree.Parent (Expression) = Syntax_Trees.Invalid_Node_Index
@@ -858,19 +876,28 @@ package body Wisi.Ada is
Args : in Wisi.Indent_Arg_Arrays.Vector)
return Wisi.Delta_Type
is
- -- We are indenting a token in 'record_definition'.
+ -- We are indenting a token in record_definition or
+ -- record_representation_clause, or a comment before 'record'.
--
- -- Args (1) is the token ID of the anchor (= TYPE); it appears as a
- -- direct child in an ancestor 'full_type_declaration'.
+ -- If record_definition, args (1) is the token ID of the anchor (=
+ -- TYPE); it appears as a direct child in an ancestor
+ -- full_type_declaration.
+ --
+ -- If record_representation_clause, args (1) is FOR, child of
+ -- record_representation_clause.
use all type WisiToken.Syntax_Trees.Node_Label;
use Ada_Process_Actions;
- Full_Type_Declaration : constant Syntax_Trees.Valid_Node_Index :=
Tree.Find_Ancestor
- (Tree_Indenting, +full_type_declaration_ID);
+ Anchor : constant Token_ID := Token_ID (Integer'(Args (1)));
+
+ Declaration : constant Syntax_Trees.Valid_Node_Index :=
Tree.Find_Ancestor
+ (Tree_Indenting,
+ (if To_Token_Enum (Anchor) = TYPE_ID
+ then +full_type_declaration_ID
+ else +record_representation_clause_ID));
- Tree_Anchor : constant Syntax_Trees.Valid_Node_Index := Tree.Find_Child
- (Full_Type_Declaration, Token_ID (Integer'(Args (1))));
+ Tree_Anchor : constant Syntax_Trees.Valid_Node_Index := Tree.Find_Child
(Declaration, Anchor);
begin
if Tree.Label (Tree_Anchor) /= WisiToken.Syntax_Trees.Shared_Terminal
then
-- Anchor is virtual; Indent_Record would return Null_Delta
@@ -880,9 +907,15 @@ package body Wisi.Ada is
declare
Anchor_Token : constant Aug_Token_Ref := Get_Aug_Token (Data, Tree,
Tree_Anchor);
- -- Args (2) is the index of RECORD in Tokens
- Record_Token : constant Aug_Token_Ref := Get_Aug_Token
- (Data, Tree, Tokens (Positive_Index_Type (Integer'(Args (2)))));
+ -- Args (2) is the index of RECORD (or a nonterminal possibly
+ -- starting with RECORD) in Tokens
+ Record_Token_Tree_Index : constant Syntax_Trees.Node_Index :=
+ Tokens (Positive_Index_Type (Integer'(Args (2))));
+ Record_Token : constant Aug_Token_Ref :=
+ (case Tree.Label (Record_Token_Tree_Index) is
+ when Shared_Terminal | Virtual_Terminal | Virtual_Identifier =>
Get_Aug_Token
+ (Data, Tree, Record_Token_Tree_Index),
+ when Nonterm => To_Aug_Token_Ref (Data.Terminals
(Tree.Min_Terminal_Index (Record_Token_Tree_Index))));
Indenting_Token : constant Aug_Token_Ref := Get_Aug_Token (Data,
Tree, Tree_Indenting);
begin
diff --git a/packages/ada-mode/wisi-ada.ads b/packages/ada-mode/wisi-ada.ads
index e1a1691..1e2fac8 100644
--- a/packages/ada-mode/wisi-ada.ads
+++ b/packages/ada-mode/wisi-ada.ads
@@ -1,11 +1,11 @@
-- Abstract :
--
--- Ada implementation of:
+-- Ada language specific indent options and functions
--
--- [1] ada-wisi-elisp-parse.el
+-- [1] ada.wy
-- [2] ada-indent-user-options.el
--
--- Copyright (C) 2017 - 2019 Free Software Foundation, Inc.
+-- Copyright (C) 2017 - 2020 Free Software Foundation, Inc.
--
-- This library is free software; you can redistribute it and/or modify it
-- under terms of the GNU General Public License as published by the Free
@@ -22,10 +22,10 @@ pragma License (Modified_GPL);
package Wisi.Ada is
- Language_Protocol_Version : constant String := "2";
+ Language_Protocol_Version : constant String := "3";
-- Defines the data passed to Initialize in Params.
--
- -- This value must match ada-wisi.el
+ -- This value must match ada-mode.el
-- ada-wisi-language-protocol-version.
--
-- Only changes once per ada-mode release. Increment as soon as
@@ -81,7 +81,6 @@ package Wisi.Ada is
Option : in Boolean;
Accumulate : in Boolean)
return Delta_Type;
- -- [1] ada-wisi-elisp-parse--indent-hanging
overriding
procedure Refactor
diff --git a/packages/wisi/wisi.gpr b/packages/ada-mode/wisi.gpr.gp
similarity index 93%
copy from packages/wisi/wisi.gpr
copy to packages/ada-mode/wisi.gpr.gp
index 27e890d..1c17529 100644
--- a/packages/wisi/wisi.gpr
+++ b/packages/ada-mode/wisi.gpr.gp
@@ -1,6 +1,7 @@
-- Abstract :
--
--- Make installed ELPA package wisi Ada code available for other projects.
+-- Make installed and source ELPA package wisi Ada code available for
+-- other projects.
--
-- Copyright (C) 2017, 2019 Free Software Foundation, Inc.
--
@@ -18,6 +19,10 @@
with "gnatcoll";
with "standard_common";
+#if ELPA="no"
+with "sal";
+with "wisitoken";
+#end if;
project Wisi is
for Source_Dirs use (".");
diff --git a/packages/ada-mode/wisitoken-parse-lr-mckenzie_recover-ada.adb
b/packages/ada-mode/wisitoken-parse-lr-mckenzie_recover-ada.adb
index 79bc58b..4658863 100644
--- a/packages/ada-mode/wisitoken-parse-lr-mckenzie_recover-ada.adb
+++ b/packages/ada-mode/wisitoken-parse-lr-mckenzie_recover-ada.adb
@@ -2,7 +2,7 @@
--
-- see spec.
--
--- Copyright (C) 2018 - 2019 Free Software Foundation, Inc.
+-- Copyright (C) 2018 - 2020 Free Software Foundation, Inc.
--
-- This library is free software; you can redistribute it and/or modify it
-- under terms of the GNU General Public License as published by the Free
@@ -992,6 +992,38 @@ package body WisiToken.Parse.LR.McKenzie_Recover.Ada is
end if;
end;
+ elsif Config.Error_Token.ID = +TICK_1_ID then
+ -- Editing "Put ('|');" => "Put ('|-');"; need to change ' to ".
+
+ declare
+ New_Config : Configuration := Config;
+ begin
+ New_Config.Strategy_Counts (Language_Fix) :=
New_Config.Strategy_Counts (Language_Fix) + 1;
+
+ declare
+ Index : WisiToken.Token_Index :=
New_Config.Current_Shared_Token;
+ Start_Line : constant WisiToken.Line_Number_Type := Terminals
+ (Config.Error_Token.Min_Terminal_Index).Line;
+ begin
+ Delete_Check (Terminals, New_Config, Index, +TICK_1_ID); --
increments index
+ loop
+ if Index > Terminals.Last_Index then
+ raise Bad_Config;
+ end if;
+ if Terminals (Index).Line /= Start_Line then
+ raise Bad_Config;
+ end if;
+ exit when Terminals (Index).ID = +TICK_1_ID;
+ Delete (Terminals, New_Config, Index); -- increments index
+ end loop;
+ Delete_Check (Terminals, New_Config, Index, +TICK_1_ID);
+ Insert (New_Config, Index, +STRING_LITERAL_ID);
+ end;
+ Local_Config_Heap.Add (New_Config);
+ if Trace_McKenzie > Detail then
+ Put ("Language_Fixes char_literal to string", New_Config);
+ end if;
+ end;
end if;
exception
when Bad_Config =>
@@ -1132,5 +1164,5 @@ package body WisiToken.Parse.LR.McKenzie_Recover.Ada is
end WisiToken.Parse.LR.McKenzie_Recover.Ada;
-- Local Variables:
--- ada-auto-case: not-upper-case
+-- ada-case-strict: nil
-- End:
diff --git a/packages/ada-mode/xref-ada.el b/packages/ada-mode/xref-ada.el
deleted file mode 100644
index cf18271..0000000
--- a/packages/ada-mode/xref-ada.el
+++ /dev/null
@@ -1,79 +0,0 @@
-;; xref-ada.el --- ada-mode backend for xref.el -*-lexical-binding:t-*-
-;;
-;; Copyright (C) 2018 - 2019 Free Software Foundation, Inc.
-
-;; This file is part of GNU Emacs.
-;;
-;; GNU Emacs is free software: you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-;;
-;; GNU Emacs is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-;; GNU General Public License for more details.
-;;
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
-
-;;; Code:
-
-(require 'wisi)
-(require 'xref)
-
-(defun xref-ada-find-backend ()
- 'xref-ada)
-
-(cl-defmethod xref-backend-definitions ((_backend (eql xref-ada)) identifier)
- (wisi-xref-ident-make
- identifier
- (lambda (ident file line column)
- (ada-check-current-project file)
- (when (null ada-xref-other-function)
- (error "no cross reference information available"))
- (let ((target
- (funcall
- ada-xref-other-function
- ident file line column)))
- ;; IMPROVEME: when drop support for emacs 24, change
- ;; ada-xref-other-function to return xref-file-location
- (list
- (xref-make
- ident
- (xref-make-file-location
- (nth 0 target) ;; file
- (nth 1 target) ;; line
- (nth 2 target)) ;; column
- ))))))
-
-(cl-defmethod xref-backend-identifier-at-point ((_backend (eql xref-ada)))
- (save-excursion
- (condition-case nil
- (let ((ident (ada-identifier-at-point))) ;; moves point to start of
ident
- (put-text-property
- 0 1
- 'xref-identifier
- (list ':file (buffer-file-name)
- ':line (line-number-at-pos)
- ':column (current-column))
- ident)
- ident)
- (error
- ;; from ada-identifier-at-point; no identifier
- nil))))
-
-(cl-defmethod xref-backend-identifier-completion-table ((_backend (eql
xref-ada)))
- (wisi-xref-identifier-completion-table))
-
-(define-minor-mode xref-ada-mode ()
- "Use xref-ada functions."
- :init-value t
- ;; The macro code sets the mode variable to the new value before we get here.
- (if xref-ada-mode
- (add-hook 'xref-backend-functions #'xref-ada-find-backend nil t)
- (remove-hook 'xref-backend-functions #'xref-ada-find-backend t)))
-
-(add-hook 'ada-mode-hook #'xref-ada-mode)
-
-(provide 'xref-ada)
diff --git a/packages/wisi/NEWS b/packages/wisi/NEWS
index 8986e40..277c1ea 100644
--- a/packages/wisi/NEWS
+++ b/packages/wisi/NEWS
@@ -1,14 +1,38 @@
GNU Emacs wisi NEWS -- history of user-visible changes.
-Copyright (C) 2019 Free Software Foundation, Inc.
+Copyright (C) 2014 - 2020 Free Software Foundation, Inc.
Please send wisi bug reports to address@hidden, with
'wisi' in the subject. If possible, use M-x report-emacs-bug.
+* wisi 3.0.1
+30 Jan 2020
+
+** fix packaging bugs
+
+** improve xref integration
+
+* wisi 3.0.0
+19 Dec 2019
+
+** parser process protocol version 5
+
+** Add project.el integration. See wisi.info for more information.
+
+** Move autocase functions from ada-mode to wisi.
+
+** Replace most ada-mode function variables with dispatching on wisi-prj.
+
+** New commands `wisi-goto-containing-statement-start',
`wisi-indent-containing-statement'.
+
+** Displayed parser errors are sorted in increasing error position.
+
* wisi 2.2.1
17 Aug 2019
+** parser process protocol version 4
+
** fix packaging bugs
* wisi 2.2.0
@@ -49,8 +73,6 @@ Please send wisi bug reports to address@hidden, with
first one found is included in the current right hand side motion
token chain.
-** The elisp parser and lexer are deleted.
-
** The process parser supports a new parse command `wisi-refactor',
which returns a new message "Edit". It is intended for performing
syntax-guided refactoring of code statements.
diff --git a/packages/wisi/README b/packages/wisi/README
index f23d1d8..f2c5329 100644
--- a/packages/wisi/README
+++ b/packages/wisi/README
@@ -1,8 +1,9 @@
-Emacs wisi package 2.2.1
+Emacs wisi package 3.0.1
-The wisi package provides utilities for using generalized LALR parsers
-(in elisp or external processes) to do indentation, fontification, and
-navigation. See ada-mode for an example of its use.
+The wisi package provides utilities for using generalized
+error-correcting LR parsers (in external processes) to do indentation,
+fontification, and navigation; and integration with Emacs package.el.
+See ada-mode for an example of its use.
It also provides wisitoken-parse_table-mode, for navigating the
diagnostic parse tables output by wisitoken-bnf-generate.
diff --git a/packages/wisi/build-wisitoken-bnf-generate.sh
b/packages/wisi/build-wisitoken-bnf-generate.sh
index 0732e5a..faa4094 100755
--- a/packages/wisi/build-wisitoken-bnf-generate.sh
+++ b/packages/wisi/build-wisitoken-bnf-generate.sh
@@ -4,4 +4,4 @@
# wisitoken development tree; see
# http://stephe-leake.org/ada/wisitoken.html
-gprbuild -p -P wisi.gpr wisitoken-bnf-generate
+gprbuild -p -j8 -P wisi.gpr wisitoken-bnf-generate
diff --git a/packages/wisi/emacs_wisi_common_parse.adb
b/packages/wisi/emacs_wisi_common_parse.adb
index f74ce37..183aaf7 100644
--- a/packages/wisi/emacs_wisi_common_parse.adb
+++ b/packages/wisi/emacs_wisi_common_parse.adb
@@ -210,6 +210,7 @@ package body Emacs_Wisi_Common_Parse is
Result.Parse_Begin_Char_Pos := WisiToken.Buffer_Pos (Get_Integer
(Command_Line, Last));
Result.Parse_Begin_Line := WisiToken.Line_Number_Type
(Get_Integer (Command_Line, Last));
Result.Parse_End_Line := WisiToken.Line_Number_Type
(Get_Integer (Command_Line, Last));
+ Result.Parse_Begin_Indent := Get_Integer (Command_Line, Last);
Result.Debug_Mode := 1 = Get_Integer (Command_Line, Last);
Result.Parse_Verbosity := Get_Integer (Command_Line, Last);
Result.Action_Verbosity := Get_Integer (Command_Line, Last);
@@ -309,7 +310,8 @@ package body Emacs_Wisi_Common_Parse is
Trace_Action := Params.Action_Verbosity;
Debug_Mode := Params.Debug_Mode;
- Partial_Parse_Active := Params.Partial_Parse_Active;
+ Partial_Parse_Active := Params.Partial_Parse_Active;
+ Parser.Partial_Parse_Active := Params.Partial_Parse_Active;
if WisiToken.Parse.LR.McKenzie_Defaulted (Parser.Table.all)
then
-- There is no McKenzie information; don't override that.
@@ -351,6 +353,8 @@ package body Emacs_Wisi_Common_Parse is
Parser.Lexer.Reset_With_String_Access
(Buffer, Params.Source_File_Name, Params.Begin_Char_Pos,
Params.Begin_Line);
+
+ -- Parser.Line_Begin_Token First, Last set by Lex_All
begin
Parser.Parse;
exception
@@ -413,7 +417,7 @@ package body Emacs_Wisi_Common_Parse is
Base_Terminals => Parser.Terminals'Unrestricted_Access,
Begin_Line => Params.Parse_Begin_Line,
End_Line => Params.Parse_End_Line,
- Begin_Indent => 0,
+ Begin_Indent => Params.Parse_Begin_Indent,
Params => "");
if Params.Max_Parallel > 0 then
diff --git a/packages/wisi/emacs_wisi_common_parse.ads
b/packages/wisi/emacs_wisi_common_parse.ads
index 1d75de6..e646eba 100644
--- a/packages/wisi/emacs_wisi_common_parse.ads
+++ b/packages/wisi/emacs_wisi_common_parse.ads
@@ -24,7 +24,7 @@ with Wisi;
with WisiToken.Parse.LR.Parser;
package Emacs_Wisi_Common_Parse is
- Protocol_Version : constant String := "4";
+ Protocol_Version : constant String := "5";
-- Protocol_Version defines the data sent between elisp and the
-- background process, except for the language-specific parameters,
-- which are defined by the Language_Protocol_Version parameter to
@@ -141,6 +141,9 @@ package Emacs_Wisi_Common_Parse is
Parse_End_Line : WisiToken.Line_Number_Type;
-- Line numbers of lines containing Parse_Begin_Byte_Pos,
Parse_End_Byte_Pos
+ Parse_Begin_Indent : Integer;
+ -- Indentation of Parse_Begin_Line
+
Debug_Mode : Boolean;
Parse_Verbosity : Integer;
Action_Verbosity : Integer;
diff --git a/packages/wisi/recover_stats.adb b/packages/wisi/recover_stats.adb
new file mode 100644
index 0000000..9172cb8
--- /dev/null
+++ b/packages/wisi/recover_stats.adb
@@ -0,0 +1,277 @@
+-- Abstract :
+--
+-- Summarize error recover log.
+--
+-- Copyright (C) 2019 Stephen Leake All Rights Reserved.
+--
+-- This program is free software; you can redistribute it and/or
+-- modify it under 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
+-- distributed with this program; see file COPYING. If not, write to
+-- the Free Software Foundation, 51 Franklin Street, Suite 500, Boston,
+-- MA 02110-1335, USA.
+
+pragma License (GPL);
+
+with Ada.Command_Line;
+with Ada.Exceptions;
+with Ada.Long_Float_Text_IO;
+with Ada.Strings.Fixed; use Ada.Strings.Fixed;
+with Ada.Strings.Maps;
+with Ada.Text_IO; use Ada.Text_IO;
+with GNAT.Traceback.Symbolic;
+with SAL.Gen_Stats.Gen_Image;
+with SAL.Long_Float_Stats;
+with WisiToken.Parse.LR;
+procedure Recover_Stats
+is
+ subtype Strategies is WisiToken.Parse.LR.Strategies;
+
+ File : File_Type;
+
+ Delimiters : constant Ada.Strings.Maps.Character_Set :=
Ada.Strings.Maps.To_Set (",() ");
+ Number : constant Ada.Strings.Maps.Character_Set :=
Ada.Strings.Maps.To_Set ("0123456789");
+
+ type Strategy_Counts is array (Strategies) of Natural;
+
+ type Recover_Label is (Full, Partial);
+
+ type Recover_Summary is record
+ Event_Count : Integer := 0;
+ -- 1 per recover event (1 line in log file)
+
+ Enqueue_Stats : SAL.Long_Float_Stats.Stats_Type;
+ Check_Stats : SAL.Long_Float_Stats.Stats_Type;
+
+ Strat_Counts_Total : Strategy_Counts := (others => 0);
+ Strat_Counts_Present : Strategy_Counts := (others => 0);
+ -- 1 per recover event if used
+
+ Ignore_Error : Integer := 0;
+ -- ie, error is name mismatch.
+
+ Recover_Count_Present : Integer := 0;
+ -- 1 per parser in recover result
+
+ Recover_Count_Total : Integer := 0;
+ -- Sum of all strategy counts
+
+ Fail_Event_Count : Integer := 0; -- for all reasons
+ Fail_Enqueue_Limit : Integer := 0;
+ Fail_No_Configs_Left : Integer := 0;
+ Fail_Programmer_Error : Integer := 0;
+ Fail_Other : Integer := 0;
+ end record;
+
+ Summary : array (Recover_Label) of Recover_Summary;
+begin
+ Open (File, In_File, Ada.Command_Line.Argument (1));
+
+ loop
+ exit when End_Of_File (File);
+ declare
+ -- The recover log is written by code in
+ -- wisitoken-parse-lr-parser.adb Parse (search for Recover_Log).
+ --
+ -- A line has the syntax:
+ -- yyyy-mm-dd hh:mm:ss <partial> <success> pre_parser_count
'<file_name>' (<parser_data>)...
+ --
+ -- where there is one (<parser_data) for each parser active after
recover. <parser_data> is:
+ --
+ -- (<strategy_counts>) <enqueue_count> <check_count> <success>
+ --
+ -- Note that the per-parser success is always TRUE; it would not be
+ -- active if recover had failed.
+
+ Line : constant String := Get_Line (File);
+ First : Integer := Index (Line, " "); -- after date
+ Last : Integer;
+
+ Label : Recover_Label := Full;
+
+ function Line_Eq (Item : in String) return Boolean
+ is begin
+ return Line (First .. First + Item'Length - 1) = Item;
+ end Line_Eq;
+
+ function Next_Integer return Integer
+ is begin
+ Find_Token
+ (Line, Number,
+ From => Last + 1,
+ Test => Ada.Strings.Inside,
+ First => First,
+ Last => Last);
+ return Integer'Value (Line (First .. Last));
+ exception
+ when Constraint_Error =>
+ raise Constraint_Error with "bad integer '" & Line (First .. Last
- 1) & "' " &
+ Ada.Text_IO.Count'Image (Ada.Text_IO.Line (File) - 1) &
First'Image & Last'Image;
+ end Next_Integer;
+
+ function Next_Boolean return Boolean
+ is begin
+ First := Last + 2;
+ Last := -1 + Index (Line, Delimiters, First);
+ return Boolean'Value (Line (First .. Last));
+ end Next_Boolean;
+
+ function Read_Strat_Counts (Strategy_Found : out Boolean) return
Strategy_Counts
+ is begin
+ Strategy_Found := False;
+ Last := Index (Line, "(", Last + 1);
+ return Result : Strategy_Counts do
+ for I in Strategies loop
+ Result (I) := Next_Integer;
+ if Result (I) > 0 then
+ Strategy_Found := True;
+ end if;
+ end loop;
+ Last := 1 + Index (Line, ")", Last + 1);
+ end return;
+ end Read_Strat_Counts;
+
+ begin
+ First := Index (Line, " ", First + 1); -- after time
+ Last := Index (Line, " ", First + 1); -- after Partial_Parse_Active
+ if Boolean'Value (Line (First + 1 .. Last - 1)) then
+ Label := Partial;
+ end if;
+
+ Summary (Label).Event_Count := Summary (Label).Event_Count + 1;
+
+ First := Last + 1;
+ if Line (First .. First + 3) = "FAIL" then
+ Summary (Label).Fail_Event_Count := Summary
(Label).Fail_Event_Count + 1;
+ First := First + 4;
+
+ if Line_Eq ("NO_CONFIGS_LEFT") then
+ Summary (Label).Fail_No_Configs_Left := Summary
(Label).Fail_No_Configs_Left + 1;
+ elsif Line_Eq ("ENQUEUE_LIMIT") then
+ Summary (Label).Fail_Enqueue_Limit := Summary
(Label).Fail_Enqueue_Limit + 1;
+ elsif Line_Eq ("PROGRAMMER_ERROR") then
+ Summary (Label).Fail_Programmer_Error := Summary
(Label).Fail_Programmer_Error + 1;
+ else
+ Summary (Label).Fail_Other := Summary (Label).Fail_Other + 1;
+ end if;
+
+ else
+ -- Process per-parser data
+ Last := Index (Line, "(", Last + 1);
+ loop
+ exit when Line (Last + 1) = ')';
+ declare
+ Strategy_Found : Boolean;
+ Strat_Counts : constant Strategy_Counts :=
Read_Strat_Counts (Strategy_Found);
+ Enqueue_Count : constant Integer := Next_Integer;
+ Check_Count : constant Integer := Next_Integer;
+ Success : constant Boolean := Next_Boolean;
+ pragma Unreferenced (Success);
+ begin
+ Summary (Label).Recover_Count_Present := Summary
(Label).Recover_Count_Present + 1;
+
+ if not Strategy_Found then
+ Summary (Label).Ignore_Error := Summary
(Label).Ignore_Error + 1;
+ else
+ -- We don't include Ignore_Error enqueue and check
counts in the
+ -- stats, because they distort them towards 1.
+ Summary (Label).Enqueue_Stats.Accumulate (Long_Float
(Enqueue_Count));
+ Summary (Label).Check_Stats.Accumulate (Long_Float
(Check_Count));
+ for I in Strategies loop
+ Summary (Label).Recover_Count_Total :=
+ Summary (Label).Recover_Count_Total + Strat_Counts
(I);
+ Summary (Label).Strat_Counts_Total (I) :=
+ Summary (Label).Strat_Counts_Total (I) +
Strat_Counts (I);
+ if Strat_Counts (I) > 0 then
+ Summary (Label).Strat_Counts_Present (I) := Summary
(Label).Strat_Counts_Present (I) + 1;
+ end if;
+ end loop;
+ end if;
+ end;
+ end loop;
+ end if;
+ end;
+ end loop;
+
+ declare
+ use Ada.Strings;
+
+ Label_Field : String (1 .. 23); -- fits strategy and fail labels
+ Count_Field : String (1 .. 8);
+ Percent_Field : String (1 .. 4);
+ -- Shared by Put_If, Put_Percent
+
+ procedure Put_If
+ (Summary_Label : in Recover_Label;
+ Name : in String;
+ Count : in Integer;
+ Always : in Boolean := False)
+ is
+ Percent_Present : constant Integer :=
+ Integer (100.0 * Float (Count) / Float (Summary
(Summary_Label).Event_Count));
+ begin
+ if Count > 0 or Always then
+ Move (Name, Label_Field); Put (Label_Field & " => ");
+ Move (Count'Image, Count_Field, Justify => Right); Put
(Count_Field);
+ Move (Percent_Present'Image & "%", Percent_Field, Justify =>
Right); Put_Line (Percent_Field);
+ end if;
+ end Put_If;
+
+ package Stats_Image is new SAL.Long_Float_Stats.Gen_Image
+ (Real_IO => Ada.Long_Float_Text_IO,
+ Default_Mean_Fore => 7,
+ Default_Mean_Aft => 0,
+ Default_Mean_Exp => 0,
+ Default_Sd_Fore => 7,
+ Default_Sd_Aft => 1,
+ Default_Sd_Exp => 0);
+
+ procedure Put_Percent (Summary_Label : in Recover_Label; Present, Total
: in Integer; Name : in String)
+ is
+ Percent_Present : constant Integer :=
+ Integer (100.0 * Float (Present) / Float (Summary
(Summary_Label).Recover_Count_Present));
+ Percent_Total : constant Integer :=
+ Integer (100.0 * Float (Total) / Float (Summary
(Summary_Label).Recover_Count_Total));
+ begin
+ Move (Name, Label_Field); Put (Label_Field);
+ Move (Present'Image, Count_Field, Justify => Right); Put
(Count_Field);
+ Move (Percent_Present'Image & "%", Percent_Field, Justify => Right);
Put (Percent_Field & " /");
+ Move (Total'Image, Count_Field, Justify => Right); Put (Count_Field);
+ Move (Percent_Total'Image & "%", Percent_Field, Justify => Right);
Put_Line (Percent_Field);
+ end Put_Percent;
+
+ begin
+ for I in Recover_Label loop
+ Put_Line (I'Image);
+ Put_Line ("present/total:" & Summary (I).Event_Count'Image & " /" &
Summary (I).Recover_Count_Total'Image);
+ if Summary (I).Event_Count > 0 then
+ Put_Line (" mean std. dev. min max");
+ Put_Line ("Enqueue: " & Stats_Image.Image (Summary
(I).Enqueue_Stats.Display));
+ Put_Line ("Check: " & Stats_Image.Image (Summary
(I).Check_Stats.Display));
+ Put_If (I, "FAIL", Summary (I).Fail_Event_Count, Always => True);
+ Put_If (I, "FAIL_ENQUEUE_LIMIT", Summary (I).Fail_Enqueue_Limit);
+ Put_If (I, "FAIL_NO_CONFIGS_LEFT", Summary
(I).Fail_No_Configs_Left);
+ Put_If (I, "FAIL_PROGRAMMER_ERROR", Summary
(I).Fail_Programmer_Error);
+ Put_If (I, "FAIL_OTHER", Summary (I).Fail_Other);
+ for J in Strategies loop
+ Put_Percent
+ (I,
+ Summary (I).Strat_Counts_Present (J),
+ Summary (I).Strat_Counts_Total (J),
+ J'Image);
+ end loop;
+ Put_Percent (I, Summary (I).Ignore_Error, Summary
(I).Ignore_Error, "Ignore_Error");
+ end if;
+ New_Line;
+ end loop;
+ end;
+exception
+when E : others =>
+ Put_Line (Ada.Exceptions.Exception_Name (E) & ": " &
Ada.Exceptions.Exception_Message (E));
+ Put_Line (GNAT.Traceback.Symbolic.Symbolic_Traceback (E));
+end Recover_Stats;
diff --git a/packages/wisi/run_wisi_common_parse.adb
b/packages/wisi/run_wisi_common_parse.adb
index e4a45c0..517b631 100644
--- a/packages/wisi/run_wisi_common_parse.adb
+++ b/packages/wisi/run_wisi_common_parse.adb
@@ -2,7 +2,7 @@
--
-- See spec.
--
--- Copyright (C) 2018 - 2019 Free Software Foundation, Inc.
+-- Copyright (C) 2018 - 2020 Free Software Foundation, Inc.
--
-- This program is free software; you can redistribute it and/or
-- modify it under terms of the GNU General Public License as
@@ -45,7 +45,7 @@ package body Run_Wisi_Common_Parse is
Put_Line (" 1 - shows spawn/terminate parallel parsers, error recovery
enter/exit");
Put_Line (" 2 - add each parser cycle, error recovery enqueue/check");
Put_Line (" 3 - parse stack in each cycle, error recovery parse
actions");
- Put_Line (" 4 - add lexer debug");
+ Put_Line (" 4 - add lexer debug, dump syntax tree");
Put_Line ("--check_limit n : set error recover token check limit" &
(if Parser.Table = null then ""
else "; default" &
Parser.Table.McKenzie_Param.Check_Limit'Image));
@@ -218,10 +218,12 @@ package body Run_Wisi_Common_Parse is
return;
end;
+ -- Parser.Line_Begin_Token First, Last set by Lex_All
+
if Cl_Params.Command = Refactor or else Cl_Params.End_Line =
Invalid_Line_Number then
-- User did not provide; run lexer to get end line.
declare
- Token : Base_Token;
+ Token : Base_Token;
Lexer_Error : Boolean;
pragma Unreferenced (Lexer_Error);
begin
diff --git a/packages/wisi/wisi-fringe.el b/packages/wisi/wisi-fringe.el
index 82f4c6a..2194b09 100644
--- a/packages/wisi/wisi-fringe.el
+++ b/packages/wisi/wisi-fringe.el
@@ -1,150 +1,152 @@
-;;; wisi-fringe.el --- show approximate error locations in the fringe
-;;
-;; Copyright (C) 2018 - 2019 Free Software Foundation, Inc.
-;;
-;; This file is part of GNU Emacs.
-;;
-;; GNU Emacs is free software: you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-;;
-;; GNU Emacs is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-;; GNU General Public License for more details.
-;;
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
-;;
-;; Design:
-;;
-;; Bitmaps are displayed in the fringe by putting a 'display property
-;; on buffer text. However, just doing that also hides the buffer
-;; text. To avoid that, we put the ’display property on a string, and
-;; then an overlay containing that string as ’before-string or
-;; ’after-string on the newline of a buffer line.
-;;
-;; We show approximate error positions in the entire buffer with
-;; single-pixel lines in the right fringe, and mark error lines with
-;; ’!!’ in the left fringe.
-
-(defun wisi-fringe-create-bitmaps ()
- "Return an array of bitmap symbols containing the fringe bitmaps."
- ;; First create the ’!!’ bitmap.
- (define-fringe-bitmap 'wisi-fringe--double-exclaim-bmp
- (vector
- #b00000000
- #b01100110
- #b01100110
- #b01100110
- #b01100110
- #b01100110
- #b00000000
- #b01100110
- #b01010110
- #b00000000))
-
- ;; In condensing the entire buffer to the current window height, we
- ;; assume a 10 point font, which allows 6 distinct line positions
- ;; each one pixel high, with one blank pixel between.
-
- (let ((result (make-vector 64 nil))
- (i 1))
- (while (<= i (length result))
- (aset result (1- i)
- (define-fringe-bitmap (intern (format "wisi-fringe--line-%d-bmp" i))
- (vector
- (if (>= i 32) #b11111111 #b00000000)
- #b00000000
- (if (>= (% i 32) 16) #b11111111 #b00000000)
- #b00000000
- (if (>= (% i 16) 8) #b11111111 #b00000000)
- #b00000000
- (if (>= (% i 8) 4) #b11111111 #b00000000)
- #b00000000
- (if (>= (% i 4) 2) #b11111111 #b00000000)
- #b00000000
- (if (>= (% i 2) 1) #b11111111 #b00000000)
- )))
- (setq i (1+ i)))
- result))
-
-(defconst wisi-fringe-bitmaps (wisi-fringe-create-bitmaps)
- "Array of 64 bitmap symbols.")
-
-(defun wisi-fringe--put-right (line bitmap-index)
- (save-excursion
- (goto-char (point-min))
- (forward-line (1- line))
- (let* ((endpos (line-end-position))
- (ov (make-overlay endpos (1+ endpos)))
- (bmp (aref wisi-fringe-bitmaps bitmap-index)))
- (overlay-put ov 'after-string (propertize "-" 'display (list
'right-fringe bmp 'compilation-error)))
- (overlay-put ov 'wisi-fringe t)
- )))
-
-(defun wisi-fringe--put-left (line)
- (save-excursion
- (goto-char (point-min))
- (forward-line (1- line))
- (let* ((endpos (line-end-position))
- (ov (make-overlay endpos (1+ endpos)))
- (bmp 'wisi-fringe--double-exclaim-bmp))
- (overlay-put ov 'before-string (propertize "-" 'display (list
'left-fringe bmp 'compilation-error)))
- (overlay-put ov 'wisi-fringe t)
- )))
-
-(defun wisi-fringe--scale (error-line buffer-lines window-line-first
window-lines)
- "Return a cons (LINE . BIN) for ERROR-LINE,
-where LINE is the line to display the error bar on, and BIN is a
-6-bit bit vector giving the relative position in that line.
-BUFFER-LINES is the count of lines in the buffer.
-WINDOW-LINE-FIRST is the first and last lines of the buffer
-visible in the window. WINDOW-LINES is the count of lines visible
-in the window."
- ;; If the end of buffer is inside the window, and this calculation
- ;; puts a mark after that, it will actually be put on the last real
- ;; line. That’s good enough for our purposes.
-
- ;; partial-lines / window-line = 6
- ;; buffer-lines / window-line = 1/scale
- ;; buffer-lines / partial-line = (window-line / partial-lines) *
(buffer-lines / window-line) = 1/6 * 1/scale
- (let* ((scale (/ window-lines (float buffer-lines)))
- (line (floor (* scale error-line)))
- (rem (- error-line (floor (/ line scale)))))
- (cons (+ window-line-first line) (lsh 1 (min 5 (floor (* rem (* 6
scale))))))))
-
-(defun wisi-fringe-clean ()
- "Remove all wisi-fringe marks."
- (remove-overlays (point-min) (point-max) 'wisi-fringe t))
-
-(defun wisi-fringe-display-errors (positions)
- "Display markers in the left and right fringe for each buffer position in
POSITIONS.
-The buffer containing POSITIONS must be current, and the window
-displaying that buffer must be current."
- ;; FIXME: recompute fringe display on scroll!
- (wisi-fringe-clean)
- (let (scaled-posns
- (buffer-lines (line-number-at-pos (point-max)))
- (window-lines (window-height))
- (window-pos-first (window-start))
- (window-pos-last (window-end))
- (window-line-first (line-number-at-pos (window-start))))
- (dolist (pos positions)
- (let* ((line (line-number-at-pos pos))
- (scaled-pos (wisi-fringe--scale line buffer-lines
window-line-first window-lines)))
- (when (and (>= pos window-pos-first)
- (<= pos window-pos-last))
- (wisi-fringe--put-left line))
- (if (and scaled-posns
- (= (caar scaled-posns) (car scaled-pos)))
- (setcdr (car scaled-posns) (logior (cdar scaled-posns) (cdr
scaled-pos)))
- (push scaled-pos scaled-posns))
- ))
-
- (dolist (pos scaled-posns)
- (wisi-fringe--put-right (car pos) (1- (cdr pos))))
- ))
-
-(provide 'wisi-fringe)
+;;; wisi-fringe.el --- show approximate error locations in the fringe
+;;
+;; Copyright (C) 2018 - 2019 Free Software Foundation, Inc.
+;;
+;; This file is part of GNU Emacs.
+;;
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+;;
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+;;
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
+;;
+;; Design:
+;;
+;; Bitmaps are displayed in the fringe by putting a 'display property
+;; on buffer text. However, just doing that also hides the buffer
+;; text. To avoid that, we put the ’display property on a string, and
+;; then an overlay containing that string as ’before-string or
+;; ’after-string on the newline of a buffer line.
+;;
+;; We show approximate error positions in the entire buffer with
+;; single-pixel lines in the right fringe, and mark error lines with
+;; ’!!’ in the left fringe.
+
+(defun wisi-fringe-create-bitmaps ()
+ "Return an array of bitmap symbols containing the fringe bitmaps."
+ ;; First create the ’!!’ bitmap.
+ (define-fringe-bitmap 'wisi-fringe--double-exclaim-bmp
+ (vector
+ #b00000000
+ #b01100110
+ #b01100110
+ #b01100110
+ #b01100110
+ #b01100110
+ #b00000000
+ #b01100110
+ #b01010110
+ #b00000000))
+
+ ;; In condensing the entire buffer to the current window height, we
+ ;; assume a 10 point font, which allows 6 distinct line positions
+ ;; each one pixel high, with one blank pixel between.
+
+ (let ((result (make-vector 64 nil))
+ (i 1))
+ (while (<= i (length result))
+ (aset result (1- i)
+ (define-fringe-bitmap (intern (format "wisi-fringe--line-%d-bmp" i))
+ (vector
+ (if (>= i 32) #b11111111 #b00000000)
+ #b00000000
+ (if (>= (% i 32) 16) #b11111111 #b00000000)
+ #b00000000
+ (if (>= (% i 16) 8) #b11111111 #b00000000)
+ #b00000000
+ (if (>= (% i 8) 4) #b11111111 #b00000000)
+ #b00000000
+ (if (>= (% i 4) 2) #b11111111 #b00000000)
+ #b00000000
+ (if (>= (% i 2) 1) #b11111111 #b00000000)
+ )))
+ (setq i (1+ i)))
+ result))
+
+(defconst wisi-fringe-bitmaps (wisi-fringe-create-bitmaps)
+ "Array of 64 bitmap symbols.")
+
+(defun wisi-fringe--put-right (line bitmap-index)
+ (save-excursion
+ (goto-char (point-min))
+ (forward-line (1- line))
+ (let* ((endpos (line-end-position))
+ (ov (make-overlay endpos (1+ endpos)))
+ (bmp (aref wisi-fringe-bitmaps bitmap-index)))
+ (overlay-put ov 'after-string (propertize "-" 'display (list
'right-fringe bmp 'compilation-error)))
+ (overlay-put ov 'wisi-fringe t)
+ )))
+
+(defun wisi-fringe--put-left (line)
+ (save-excursion
+ (goto-char (point-min))
+ (forward-line (1- line))
+ (let* ((endpos (line-end-position))
+ (ov (make-overlay endpos (1+ endpos)))
+ (bmp 'wisi-fringe--double-exclaim-bmp))
+ (overlay-put ov 'before-string (propertize "-" 'display (list
'left-fringe bmp 'compilation-error)))
+ (overlay-put ov 'wisi-fringe t)
+ )))
+
+(defun wisi-fringe--scale (error-line buffer-lines window-line-first
window-lines)
+ "Return a cons (LINE . BIN) for ERROR-LINE,
+where LINE is the line to display the error bar on, and BIN is a
+6-bit bit vector giving the relative position in that line.
+BUFFER-LINES is the count of lines in the buffer.
+WINDOW-LINE-FIRST is the first and last lines of the buffer
+visible in the window. WINDOW-LINES is the count of lines visible
+in the window."
+ ;; If the end of buffer is inside the window, and this calculation
+ ;; puts a mark after that, it will actually be put on the last real
+ ;; line. That’s good enough for our purposes.
+
+ ;; partial-lines / window-line = 6
+ ;; buffer-lines / window-line = 1/scale
+ ;; buffer-lines / partial-line = (window-line / partial-lines) *
(buffer-lines / window-line) = 1/6 * 1/scale
+ (let* ((scale (/ window-lines (float buffer-lines)))
+ (line (floor (* scale error-line)))
+ (rem (- error-line (floor (/ line scale)))))
+ (cons (+ window-line-first line) (lsh 1 (min 5 (floor (* rem (* 6
scale))))))))
+
+(defun wisi-fringe-clean ()
+ "Remove all wisi-fringe marks."
+ (remove-overlays (point-min) (point-max) 'wisi-fringe t))
+
+(defun wisi-fringe-display-errors (positions)
+ "Display markers in the left and right fringe for each buffer position in
POSITIONS.
+The buffer containing POSITIONS must be current, and the window
+displaying that buffer must be current."
+ ;; We don't recompute fringe display on scroll, because the user
+ ;; will probably have edited the code by then, triggering a new
+ ;; parse.
+ (wisi-fringe-clean)
+ (let (scaled-posns
+ (buffer-lines (line-number-at-pos (point-max)))
+ (window-lines (window-height))
+ (window-pos-first (window-start))
+ (window-pos-last (window-end))
+ (window-line-first (line-number-at-pos (window-start))))
+ (dolist (pos positions)
+ (let* ((line (line-number-at-pos pos))
+ (scaled-pos (wisi-fringe--scale line buffer-lines
window-line-first window-lines)))
+ (when (and (>= pos window-pos-first)
+ (<= pos window-pos-last))
+ (wisi-fringe--put-left line))
+ (if (and scaled-posns
+ (= (caar scaled-posns) (car scaled-pos)))
+ (setcdr (car scaled-posns) (logior (cdar scaled-posns) (cdr
scaled-pos)))
+ (push scaled-pos scaled-posns))
+ ))
+
+ (dolist (pos scaled-posns)
+ (wisi-fringe--put-right (car pos) (1- (cdr pos))))
+ ))
+
+(provide 'wisi-fringe)
diff --git a/packages/wisi/wisi-parse-common.el
b/packages/wisi/wisi-parse-common.el
index dd9d862..2140b50 100644
--- a/packages/wisi/wisi-parse-common.el
+++ b/packages/wisi/wisi-parse-common.el
@@ -1,4 +1,4 @@
-;;; wisi-parse-common.el --- declarations used by wisi-parse.el,
wisi-ada-parse.el, and wisi.el
+;;; wisi-parse-common.el --- declarations used by wisi-parse.el,
wisi-ada-parse.el, and wisi.el -*- lexical-binding:t -*-
;;
;; Copyright (C) 2014, 2015, 2017 - 2019 Free Software Foundation, Inc.
;;
@@ -74,10 +74,9 @@ and parse the whole buffer."
(cl-defgeneric wisi-parse-format-language-options ((parser wisi-parser))
"Return a string to be sent to the parser, containing settings
for the language-specific parser options."
- ;; not needed for the elisp parser, which can see the options directly.
)
-(cl-defgeneric wisi-parse-expand-region ((parser wisi-parser) begin end)
+(cl-defgeneric wisi-parse-expand-region ((_parser wisi-parser) begin end)
"Return a cons SEND-BEGIN . SEND-END that is an expansion of
region BEGIN END that starts and ends at points the parser can
handle gracefully."
@@ -119,7 +118,7 @@ Return nil if no match found before eob."
(goto-char (cdr region))
))
-(cl-defgeneric wisi-parse-adjust-indent ((parser wisi-parser) indent _repair)
+(cl-defgeneric wisi-parse-adjust-indent ((_parser wisi-parser) indent _repair)
"Adjust INDENT for REPAIR (a wisi--parse-error-repair struct). Return new
indent."
indent)
diff --git a/packages/wisi/wisi-prj.el b/packages/wisi/wisi-prj.el
new file mode 100644
index 0000000..833a514
--- /dev/null
+++ b/packages/wisi/wisi-prj.el
@@ -0,0 +1,1466 @@
+;;; wisi-prj.el --- project definition files -*- lexical-binding:t -*-
+;;
+;; Copyright (C) 2019 - 2020 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/>.
+
+;;; Usage:
+;;
+;; See wisi.info (compiled from wisi.texi).
+
+;;; Code:
+
+(require 'cl-lib)
+(require 'find-file)
+(require 'wisi)
+
+(cl-defstruct wisi-prj
+ name ;; A user-friendly string, used in menus and messages.
+
+ compile-env
+ ;; List of strings NAME=VALUE for `compilation-environment'; used
+ ;; when running the compiler or makefile. Also prepended to
+ ;; `process-environment' when the project file is parsed, or when
+ ;; the project file is used by a tool in an external process.
+
+ file-env
+ ;; Environment (list of strings NAME=VALUE) set in project file;
+ ;; prepended to `process-environment' running tools in an external
+ ;; process.
+
+ compiler
+ xref
+ ;; xref functionality is often provided by the compiler. We allow
+ ;; for separate compiler and xref objects, to handle the case where
+ ;; the compiler is a cross-compiler for an embedded target, and xref
+ ;; is provided by a host compiler.
+
+ (case-exception-files nil)
+ ;; List of casing exception files; from `casing' project variable.
+ ;;
+ ;; New exceptions may be added interactively via
+ ;; `wisi-case-create-exception'. If an exception is defined in
+ ;; multiple files, the first occurence is used.
+ ;;
+ ;; The file format is one word per line, which gives the casing to be
+ ;; used for that word in 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."
+
+ (case-full-exceptions '())
+ ;; Alist of full words that have special casing, built from
+ ;; case-exception-files. Indexed by properly cased word; value is t.
+
+ (case-partial-exceptions '())
+ ;; Alist of partial words that have special casing, built from
+ ;; project casing files list partial word exceptions. Indexed by
+ ;; properly cased word; value is t.
+
+ source-path ;; list of absolute directory file names
+
+ file-pred
+ ;; Function taking an absolute file name, returns non-nil
+ ;; if the file should be included in `project-files'.
+ )
+
+(defun wisi-prj-require-prj ()
+ "Return current `wisi-prj' object.
+Throw an error if current project is not an wisi-prj."
+ (let ((prj (project-current)))
+ (if (wisi-prj-p prj)
+ prj
+ (error "current project is not a wisi project."))))
+
+(defun wisi-prj-current-prj ()
+ "Return current `wisi-prj' object.
+If (project-current) does not return a wisi-prj, return a default prj."
+ (let ((prj (project-current)))
+ (if (wisi-prj-p prj)
+ prj
+ (make-wisi-prj :name "default"))))
+
+(defvar wisi-prj-file-extensions (list "prj")
+ "List of wisi project file extensions.
+Used when searching for project files.")
+
+(defvar wisi-prj--cache nil
+ "Alist holding currently parsed project objects.
+Indexed by absolute project file name.")
+
+(cl-defgeneric wisi-prj-default (prj)
+ "Return a project with default values.
+Used to reset a project before refreshing it.")
+
+(cl-defgeneric wisi-prj-parse-one (_project _name _value)
+ "If recognized by PROJECT, set NAME, VALUE in PROJECT, return non-nil.
+Else return nil."
+ nil)
+
+(cl-defgeneric wisi-prj-parse-final (_project _prj-file-name)
+ "Do any final processing on PROJECT
+after the project file PRJ-FILE-NAME is parsed."
+ nil)
+
+(cl-defgeneric wisi-prj-select (project)
+ "PROJECT is selected; perform any required actions.")
+
+(cl-defgeneric wisi-prj-deselect (project)
+ "PROJECT is deselected; undo any select actions.")
+
+(cl-defgeneric wisi-prj-refresh-cache (prj not-full)
+ "Reparse the project file for PRJ, refresh all cached data in PRJ.
+If NOT-FULL is non-nil, very slow refresh operations may be skipped.")
+
+(cl-defgeneric wisi-prj-identifier-ignore-case (prj)
+ "Return non-nil if case should be ignored when comparing identifiers.")
+
+;; We provide nil defaults for some methods, because some language
+;; modes don't have a language-specific compiler (eg java-wisi) or
+;; xref process (eg gpr-mode).
+
+(cl-defgeneric wisi-compiler-parse-one (compiler project name value)
+ "Set NAME, VALUE in COMPILER, if recognized by COMPILER.
+PROJECT is an `wisi-prj' object; COMPILER is `wisi-prj-compiler'.")
+
+(cl-defgeneric wisi-compiler-parse-final (_compiler _project _prj-file-name)
+ "Do any compiler-specific processing on COMPILER and PROJECT
+after the project file PRJ-FILE-NAME is parsed."
+ nil)
+
+(cl-defgeneric wisi-compiler-select-prj (_compiler _project)
+ "PROJECT has been selected; do any compiler-specific actions required."
+ nil)
+
+(cl-defgeneric wisi-compiler-deselect-prj (_compiler _project)
+ "PROJECT has been de-selected; undo any compiler-specific select actions."
+ nil)
+
+(cl-defgeneric wisi-compiler-show-prj-path (compiler)
+ "Display buffer listing project file search path.")
+
+(cl-defgeneric wisi-compiler-fix-error (compiler source-buffer)
+ "Attempt to fix a compilation error, return non-nil if fixed.
+Current buffer is compilation buffer; point is at an error message.
+SOURCE-BUFFER contains the source code referenced in the error message.")
+
+(cl-defgeneric wisi-xref-parse-one (_xref _project _name _value)
+ "If recognized by XREF, set NAME, VALUE in XREF, return non-nil.
+Else return nil."
+ nil)
+
+(cl-defgeneric wisi-xref-parse-final (_xref _project _prj-file-name)
+ "Do any xref-specific processing on XREF and PROJECT
+after the project file PRJ-FILE-NAME is parsed."
+ nil)
+
+(cl-defgeneric wisi-xref-select-prj (_xref _project)
+ "PROJECT has been selected; do any xref-specific actions required."
+ nil)
+
+(cl-defgeneric wisi-xref-deselect-prj (_xref _project)
+ "PROJECT has been de-selected; undo any xref-specific select actions."
+ nil)
+
+(cl-defgeneric wisi-xref-refresh-cache (_xref _project _no-full)
+ "Refresh cached information in XREF. If no-full is non-nil,
+slow refresh operations may be skipped."
+ nil)
+
+(cl-defgeneric wisi-xref-definitions (_xref project item)
+ "Return all definitions (classwide) of ITEM (an xref-item), as a list of
xref-items.")
+
+(cl-defgeneric wisi-xref-references (_xref project item)
+ "Return all references to ITEM (an xref-item), as a list of xref-items.")
+
+(cl-defgeneric wisi-xref-other (project &key identifier filename line column)
+ "Return cross reference information.
+PROJECT - dispatching object, normally a `wisi-prj' object.
+IDENTIFIER - an identifier or operator_symbol
+FILENAME - absolute filename containing the identifier
+LINE - line number containing the identifier (may be nil)
+COLUMN - Emacs column of the start of the identifier (may be nil)
+Point is on the start of the identifier.
+Returns a list (FILE LINE COLUMN) giving the corresponding location;
+FILE is an absolute file name. If point is at the specification, the
+corresponding location is the
+body, and vice versa.")
+
+(defvar-local wisi-xref-full-path nil
+ "If non-nil, xref functions show full paths in results.")
+
+(defun wisi-goto-source (file line column)
+ "Find and select FILE, at LINE and COLUMN.
+FILE may be absolute, or on `compilation-search-path'.
+LINE, COLUMN are Emacs origin."
+ (let ((file-1
+ (if (file-name-absolute-p file) file
+ (ff-get-file-name compilation-search-path file))))
+ (if file-1
+ (setq file file-1)
+ (error "File %s not found; installed library, or set project?" file))
+ )
+
+ (push-mark (point) t)
+
+ (let ((buffer (get-file-buffer file)))
+ (cond
+ ((bufferp buffer)
+ ;; use pop-to-buffer, so package other-frame-window works.
+ (pop-to-buffer buffer (list #'display-buffer-same-window)))
+
+ ((file-exists-p file)
+ (find-file file))
+
+ (t
+ (error "'%s' not found" file))))
+
+ ;; move the cursor to the correct position
+ (goto-char (point-min))
+ (forward-line (1- line))
+ (forward-char column))
+
+(defun wisi-show-xref (xref)
+ "Display XREF location."
+ (let ((marker (xref-location-marker (xref-item-location xref))))
+ (pop-to-buffer (marker-buffer marker) (list #'display-buffer-same-window))
+ (goto-char (marker-position marker))))
+
+(defun wisi-get-identifier (prompt)
+ "Get identifier at point, or if no identifier at point, or with user arg,
prompt for one."
+ ;; Similar to xref--read-identifier, but uses a different completion
+ ;; table, because we want a more specific reference.
+ (let* ((backend (xref-find-backend))
+ (def (xref-backend-identifier-at-point backend)))
+
+ (cond
+ ((or current-prefix-arg
+ (not def))
+ (let ((id
+ (completing-read
+ (if def
+ (format "%s (default %s): " prompt def)
+ prompt)
+ (wisi-names t)
+ nil nil nil
+ 'xref--read-identifier-history def)))
+ (if (equal id "")
+ (user-error "No identifier provided")
+ id)))
+ (t def))))
+
+(defun wisi-goto-spec/body (identifier)
+ "Goto declaration or body for IDENTIFIER (default symbol at point).
+If no symbol at point, or with prefix arg, prompt for symbol, goto spec."
+ (interactive (list (wisi-get-identifier "Goto spec/body of: ")))
+ (let ((prj (project-current)))
+ (wisi-show-xref
+ (wisi-xref-ident-make
+ identifier
+ (lambda (ident file line column)
+ (let ((target (wisi-xref-other
+ (wisi-prj-xref prj) prj
+ :identifier ident
+ :filename file
+ :line line
+ :column column)))
+ (xref-make ident
+ (xref-make-file-location
+ (nth 0 target) ;; file
+ (nth 1 target) ;; line
+ (nth 2 target))) ;; column
+ ))))
+ ))
+
+(cl-defgeneric wisi-prj-identifier-at-point (_project)
+ "Return the identifier at point, move point to start of
+identifier. Signal an error if no identifier is at point."
+ (let ((ident (thing-at-point 'symbol)))
+ (when ident
+ (skip-syntax-backward "w_")
+ ident)))
+
+(defun wisi-check-current-project (file-name &optional default-prj-function)
+ "If FILE-NAME (must be absolute) is found in the current
+project source directories, return the current
+project. Otherwise, if the current project is a wisi project,
+throw an error. If the current project is not a wisi project,
+and DEFAULT-PRJ-FUNCTION is non-nil, use it to return a default
+project. Otherwise throw an error."
+ (let ((visited-file (file-truename file-name)) ;; file-truename handles
symbolic links
+ (project (project-current)))
+ (if (wisi-prj-p project)
+ (let ((found-file (locate-file (file-name-nondirectory visited-file)
+ (wisi-prj-source-path project))))
+ (unless found-file
+ (error "current file not part of current project; wrong project?"))
+
+ (setq found-file (file-truename found-file))
+
+ ;; (nth 10 (file-attributes ...)) is the inode; required when hard
+ ;; links are present.
+ (let* ((visited-file-inode (nth 10 (file-attributes visited-file)))
+ (found-file-inode (nth 10 (file-attributes found-file))))
+ (unless (equal visited-file-inode found-file-inode)
+ (error "%s (opened) and %s (found in project) are two different
files"
+ file-name found-file)))
+ project)
+
+ ;; create a project?
+ (if default-prj-function
+ (funcall default-prj-function nil (file-name-directory file-name))
+ (error "current project is not a wisi project."))
+ )))
+
+(cl-defgeneric wisi-xref-parents (xref project &key identifier filename line
column)
+ "Displays parent type declarations.
+XREF - dispatching object.
+PROJECT - a `wisi-prj' object.
+IDENTIFIER - an identifier or operator_symbol
+FILENAME - absolute filename containing the identifier
+LINE - line number containing the identifier
+COLUMN - Emacs column of the start of the identifier
+
+Displays a buffer in compilation-mode giving locations of the parent type
declarations.")
+
+(defun wisi-show-declaration-parents ()
+ "Display the locations of the parent type declarations of the type
identifier around point."
+ (interactive)
+ (let ((project (wisi-check-current-project (buffer-file-name))))
+ (wisi-xref-parents
+ (wisi-prj-xref project)
+ project
+ :identifier (wisi-prj-identifier-at-point project)
+ :filename (file-name-nondirectory (buffer-file-name))
+ :line (line-number-at-pos)
+ :column (current-column))
+ ))
+
+(cl-defgeneric wisi-xref-all (xref project &key identifier filename line
column local-only append)
+ "Displays cross reference information.
+XREF - dispatching object.
+PROJECT - a `wisi-prj' object.
+IDENTIFIER - an identifier or operator_symbol (a string).
+FILENAME - absolute filename containing the identifier
+LINE - line number containing the identifier
+COLUMN - Emacs column of the start of the identifier
+LOCAL-ONLY - if t, show references in FILE only
+APPEND - if t, keep previous output in result buffer
+Displays a buffer in compilation-mode giving locations where the
+identifier is declared or referenced.")
+
+(defun wisi-show-references (&optional append)
+ "Show all references of identifier at point.
+With prefix, keep previous references in output buffer."
+ (interactive "P")
+ (let ((project (wisi-check-current-project (buffer-file-name))))
+ (wisi-xref-all
+ (wisi-prj-xref project)
+ project
+ :identifier (wisi-prj-identifier-at-point project)
+ :filename (file-name-nondirectory (buffer-file-name))
+ :line (line-number-at-pos)
+ :column (current-column)
+ :local-only nil
+ :append append)
+ ))
+
+(defun wisi-show-local-references (&optional append)
+ "Show all references of identifier at point occuring in current file.
+With prefix, keep previous references in output buffer."
+ (interactive "P")
+ (let ((project (wisi-check-current-project (buffer-file-name))))
+ (wisi-xref-all
+ (wisi-prj-xref project)
+ project
+ :identifier (wisi-prj-identifier-at-point project)
+ :filename (file-name-nondirectory (buffer-file-name))
+ :line (line-number-at-pos)
+ :column (current-column)
+ :local-only t
+ :append append)
+ ))
+
+(cl-defgeneric wisi-xref-overriding (xref project &key identifier filename
line column)
+ "Displays a buffer in compilation-mode giving locations of the overriding
declarations.
+XREF - dispatching object.
+PROJECT - a `wisi-prj' object.
+IDENTIFIER - an identifier or operator_symbol
+FILENAME - filename containing the identifier
+LINE - line number containing the identifier
+COLUMN - Emacs column of the start of the identifier ")
+
+(defun wisi-show-overriding ()
+ "Show all overridings of identifier at point."
+ (interactive)
+ (let ((project (wisi-check-current-project (buffer-file-name))))
+ (wisi-xref-overriding
+ (wisi-prj-xref project)
+ project
+ :identifier (wisi-prj-identifier-at-point project)
+ :filename (file-name-nondirectory (buffer-file-name))
+ :line (line-number-at-pos)
+ :column (current-column))
+ ))
+
+(cl-defgeneric wisi-xref-overridden (xref project &key identifier filename
line column)
+ "Returns a list (FILE LINE COLUMN) giving the location of the overridden
declaration.
+XREF - dispatching object.
+PROJECT - a `wisi-prj' object.
+IDENTIFIER - an identifier or operator_symbol
+FILENAME - absolute filename containing the identifier
+LINE - line number containing the identifier
+COLUMN - Emacs column of the start of the identifier")
+
+(defun wisi-show-overridden ()
+ "Show the overridden declaration of identifier at point."
+ (interactive)
+ (let* ((project (wisi-check-current-project (buffer-file-name)))
+ (target
+ (wisi-xref-overridden
+ (wisi-prj-xref project)
+ project
+ :identifier (wisi-prj-identifier-at-point project)
+ :filename (file-name-nondirectory (buffer-file-name))
+ :line (line-number-at-pos)
+ :column (current-column))))
+
+ (wisi-goto-source (nth 0 target)
+ (nth 1 target)
+ (nth 2 target))
+ ))
+
+;;;; wisi-prj specific methods
+
+(cl-defmethod project-roots ((_project wisi-prj))
+ ;; Not meaningful
+ nil)
+
+(cl-defmethod project-files ((project wisi-prj) &optional dirs)
+ (let (result)
+ (dolist (dir (or dirs
+ (wisi-prj-source-path project)))
+ (mapc
+ (lambda (absfile)
+ (when (and (not (string-equal "." (substring absfile -1)))
+ (not (string-equal ".." (substring absfile -2)))
+ (not (file-directory-p absfile))
+ (or (null (wisi-prj-file-pred project))
+ (funcall (wisi-prj-file-pred project) absfile)))
+ (push absfile result)))
+ (when (file-readable-p dir) ;; GNAT puts non-existing dirs on path.
+ (directory-files dir t))))
+ result))
+
+(defun wisi-refresh-prj-cache (not-full)
+ "Refresh all cached data in the current project, and re-select it.
+With prefix arg, very slow refresh operations may be skipped."
+ (interactive "P")
+ (let ((prj (project-current)))
+ (unless (wisi-prj-p prj)
+ (error "current project is not a wisi project"))
+ (wisi-prj-refresh-cache prj not-full)
+ (wisi-prj-select prj)))
+
+(defvar wisi-prj--current-file nil
+ "Current wisi project file (the most recently selected); an
+absolute file name.")
+
+(defun wisi-prj-clear-current ()
+ "Clear the current project selection; make no project current."
+ (interactive)
+ (setq wisi-prj--current-file nil))
+
+(defun wisi-prj-show ()
+ "Show name of current project."
+ (interactive)
+ (message
+ (cond
+ (wisi-prj--current-file
+ (wisi-prj-name (cdr (assoc wisi-prj--current-file wisi-prj--cache))))
+ (t
+ (let ((prj (project-current)))
+ (if (wisi-prj-p prj)
+ (wisi-prj-name prj)
+ "not a wisi project"))))))
+
+(cl-defmethod wisi-prj-parse-final (project _prj-file)
+ (wisi--case-read-all-exceptions project))
+
+(cl-defmethod wisi-prj-refresh-cache ((project wisi-prj) not-full)
+ (when wisi-prj--cache
+ (wisi-prj-deselect project)
+ (let ((prj-file (car (rassoc project wisi-prj--cache))))
+ (setq wisi-prj--cache (delete (cons prj-file project) wisi-prj--cache))
+ (setq project (wisi-prj-default project))
+ (wisi-prj-parse-file :prj-file prj-file :init-prj project :cache t)
+ (wisi-prj-select project)))
+ (wisi-xref-refresh-cache (wisi-prj-xref project) project not-full))
+
+(cl-defmethod wisi-prj-select ((project wisi-prj))
+ (setq compilation-search-path (wisi-prj-source-path project))
+
+ ;; ‘compilation-environment’ is buffer-local, but the user might
+ ;; delete that buffer. So set both global and local.
+ (let ((comp-env
+ (append
+ (wisi-prj-compile-env project)
+ (wisi-prj-file-env project)
+ (copy-sequence (wisi-prj-file-env project))))
+ (comp-buf (get-buffer "*compilation*")))
+ (when (buffer-live-p comp-buf)
+ (with-current-buffer comp-buf
+ (setq compilation-environment comp-env)))
+ (set-default 'compilation-environment comp-env))
+
+ (wisi-compiler-select-prj (wisi-prj-compiler project) project)
+ (wisi-xref-select-prj (wisi-prj-xref project) project))
+
+(cl-defmethod wisi-prj-deselect ((project wisi-prj))
+ (wisi-xref-deselect-prj (wisi-prj-xref project) project)
+ (wisi-compiler-deselect-prj (wisi-prj-compiler project) project)
+ (setq compilation-environment nil)
+ (setq compilation-search-path nil))
+
+(defvar wisi-prj-parse-hook nil
+ "Hook run at start of `wisi-prj-parse-file'.")
+
+(defvar wisi-prj-parser-alist (list (cons "prj" #'wisi-prj-parse-file-1))
+ "Alist of parsers for project files, indexed by file extension.
+Parser is called with two arguments; the project file name and
+a project. Parser should update the project with values from the file.")
+
+(cl-defmethod wisi-prj-parse-one (project name value)
+ "If NAME is a wisi-prj slot, set it to VALUE, return t.
+Else return nil."
+ (cond
+ ((string= name "casing")
+ (cl-pushnew (expand-file-name
+ (substitute-in-file-name value))
+ (wisi-prj-case-exception-files project)
+ :test #'string-equal)
+ t)
+
+ ((string= name "src_dir")
+ (cl-pushnew (directory-file-name (expand-file-name
(substitute-in-file-name value)))
+ (wisi-prj-source-path project)
+ :test #'string-equal)
+ t)
+
+ ((= ?$ (elt name 0))
+ ;; Process env var.
+ (setf (wisi-prj-file-env project)
+ (cons (concat (substring name 1) "=" (substitute-in-file-name value))
+ (wisi-prj-file-env project)))
+ t)
+
+ ))
+
+(defvar-local wisi-prj-parse-undefined-function nil
+ "Function called if a project file variable name is not recognized.
+Called with three args: PROJECT NAME VALUE.")
+
+(defun wisi-prj-parse-file-1 (prj-file project)
+ "Wisi project file parser."
+ (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]+\\)=\\(.*\\)")
+ (let ((name (match-string 1))
+ (value (match-string 2))
+ result)
+
+ ;; Both compiler and xref need to see some settings; eg gpr_file, env
vars.
+ (when (wisi-compiler-parse-one (wisi-prj-compiler project) project
name value)
+ (setq result t))
+ (when (wisi-xref-parse-one (wisi-prj-xref project) project name value)
+ (setq result t))
+
+ (unless result
+ (setq result (wisi-prj-parse-one project name value)))
+
+ (when (and (not result)
+ wisi-prj-parse-undefined-function)
+ (funcall wisi-prj-parse-undefined-function project name value))
+
+ ))
+
+ (forward-line 1)
+ )
+ ))
+
+(cl-defun wisi-prj-parse-file (&key prj-file init-prj cache)
+ "Read project file PRJ-FILE with default values from INIT-PRJ.
+PRJ-FILE parser is from `wisi-prj-parser-alist'; if that yields
+no parser, no error occurs; the file is just a placeholder. If
+CACHE is non-nil, add the project to `wisi-prj--cache'. In any
+case, return the project."
+ (setq prj-file (expand-file-name prj-file))
+
+ (run-hooks 'wisi-prj-parse-hook)
+
+ (let* ((default-directory (file-name-directory prj-file))
+ (parser (cdr (assoc (file-name-extension prj-file)
wisi-prj-parser-alist)))
+ (project init-prj)
+ (process-environment (append (wisi-prj-compile-env init-prj)
process-environment)))
+
+ (when parser
+ ;; If no parser, prj-file is just a placeholder; there is no file to
parse.
+ ;; For example, sal-android-prj has no project file.
+ (funcall parser prj-file project)
+ (wisi-prj-parse-final project prj-file)
+ (wisi-compiler-parse-final (wisi-prj-compiler project) project prj-file)
+ (wisi-xref-parse-final (wisi-prj-xref project) project prj-file))
+
+ (when cache
+ ;; Cache the project properties
+ (if (assoc prj-file wisi-prj--cache)
+ (setcdr (assoc prj-file wisi-prj--cache) project)
+ (push (cons prj-file project) wisi-prj--cache)))
+
+ project))
+
+(defun wisi-prj-show-prj-path ()
+ "Show the compiler project file search path."
+ (interactive)
+ (wisi-compiler-show-prj-path (wisi-prj-compiler (wisi-prj-require-prj))))
+
+(defun wisi-prj-show-src-path ()
+ "Show the project source file search path."
+ (interactive)
+ (if compilation-search-path
+ (progn
+ (pop-to-buffer (get-buffer-create "*source file search path*"))
+ (erase-buffer)
+ (dolist (file compilation-search-path)
+ (insert (format "%s\n" file))))
+ (message "no source file search path set")
+ ))
+
+(defun wisi-fix-compiler-error ()
+ "Attempt to fix the current compiler error.
+Point must be at the source location referenced in a compiler error.
+In `compilation-last-buffer', point must be at the compiler error.
+Leave point at fixed code."
+ (interactive)
+ (let ((source-buffer (current-buffer))
+ (line-move-visual nil)); screws up next-line otherwise
+
+ (cond
+ ((equal compilation-last-buffer wisi-error-buffer)
+ (set-buffer source-buffer)
+ (wisi-repair-error))
+
+ (t
+ (with-current-buffer compilation-last-buffer
+ (let ((comp-buf-pt (point))
+ (success
+ (wisi-compiler-fix-error
+ (wisi-prj-compiler (wisi-prj-require-prj))
+ source-buffer)))
+ ;; restore compilation buffer point
+ (set-buffer compilation-last-buffer)
+ (goto-char comp-buf-pt)
+
+ (unless success
+ (error "error not recognized"))
+ )))
+ )))
+
+;;;; auto-casing
+
+(defvar-local wisi-auto-case nil
+ "Buffer-local value indicating whether to change case while typing.
+When non-nil, automatically change case of preceding word while
+typing. Casing of keywords is done according to
+`wisi-case-keyword', identifiers according to
+`wisi-case-identifier'."
+ ;; This is not a defcustom, because it's buffer-local.
+ )
+
+(defvar-local wisi-case-keyword 'lower-case
+ "Indicates how to adjust the case of `wisi-keywords'.
+Value is one of lower-case, upper-case."
+ ;; This is not a defcustom, because it's buffer-local
+ )
+
+(defvar-local wisi-case-identifier 'mixed-case
+ "Buffer-local value indicating how to case language keywords.
+Value is one of:
+
+- mixed-case : Mixed_Case
+- lower-case : lower_case
+- upper-case : UPPER_CASE")
+
+(defvar-local wisi-case-strict t
+ "If nil, preserve uppercase chars in identifiers.")
+
+(defvar-local wisi-language-keywords nil
+ "List of keywords for auto-case.")
+
+(defvar-local wisi-case-adjust-p-function nil
+ "Function taking one argument, the typed char; called from wisi-case-adjust.
+Return non-nil if case of symbol at point should be adjusted.
+Point is on last char of symbol.")
+
+(defun wisi-case-show-files ()
+ "Show casing files list for the current project."
+ (interactive)
+ (let ((project (project-current)))
+
+ (if (and (wisi-prj-p project)
+ (wisi-prj-case-exception-files project))
+ (progn
+ (pop-to-buffer (get-buffer-create "*casing files*"))
+ (erase-buffer)
+ (dolist (file (wisi-prj-case-exception-files project))
+ (insert (format "%s\n" file))))
+ (message "no casing files")
+ )))
+
+(defun wisi--case-save-exceptions (full-exceptions partial-exceptions
file-name)
+ "Save FULL-EXCEPTIONS, PARTIAL-EXCEPTIONS to the file FILE-NAME."
+ ;; If there is a buffer visiting file-name, it may be out of date
+ ;; due to a previous save-exceptions, which will give a user prompt
+ ;; about editing a file that has changed on disk. Update the buffer
+ (let ((buf (get-file-buffer file-name)))
+ (when buf
+ (with-current-buffer buf
+ (revert-buffer nil t t))))
+
+ (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 wisi--case-read-exceptions (file-name)
+ "Read the content of the casing exception file FILE-NAME.
+Return (cons full-exceptions partial-exceptions)."
+ (setq file-name (expand-file-name (substitute-in-file-name file-name)))
+ (if (file-readable-p file-name)
+ (let (full-exceptions partial-exceptions word)
+ (with-temp-buffer
+ (insert-file-contents file-name)
+ (while (not (eobp))
+
+ (setq word (buffer-substring-no-properties
+ (point) (save-excursion (skip-syntax-forward "w_")
(point))))
+
+ (if (char-equal (string-to-char word) ?*)
+ ;; partial word exception
+ (progn
+ (setq word (substring word 1))
+ (unless (assoc-string word partial-exceptions t)
+ (push (cons word t) partial-exceptions)))
+
+ ;; full word exception
+ (unless (assoc-string word full-exceptions t)
+ (push (cons word t) full-exceptions)))
+
+ (forward-line 1))
+ )
+ (cons full-exceptions partial-exceptions))
+
+ ;; else file not readable; might be a new project with no
+ ;; exceptions yet, so just return empty pair
+ (message "'%s' is not a readable file." file-name)
+ '(nil . nil)
+ ))
+
+(defun wisi--case-merge-exceptions (result new)
+ "Merge NEW exeptions into RESULT.
+An item in both lists has the RESULT value."
+ (dolist (item new)
+ (unless (assoc-string (car item) result t)
+ (push item result)))
+ result)
+
+(defun wisi--case-merge-all-exceptions (exceptions project)
+ "Merge EXCEPTIONS into PROJECT case-full-exceptions,
case-partial-exceptions."
+ (setf (wisi-prj-case-full-exceptions project)
+ (wisi--case-merge-exceptions (wisi-prj-case-full-exceptions project)
+ (car exceptions)))
+ (setf (wisi-prj-case-partial-exceptions project)
+ (wisi--case-merge-exceptions (wisi-prj-case-partial-exceptions project)
+ (cdr exceptions))))
+
+(defun wisi--case-read-all-exceptions (project)
+ "Read case exceptions from all files in PROJECT casing files."
+ (setf (wisi-prj-case-full-exceptions project) '())
+ (setf (wisi-prj-case-partial-exceptions project) '())
+
+ (dolist (file (wisi-prj-case-exception-files project))
+ (wisi--case-merge-all-exceptions (wisi--case-read-exceptions file)
project)))
+
+(defun wisi--case-add-exception (word exceptions)
+ "Add case exception WORD to EXCEPTIONS, replacing current entry, if any."
+ (if (assoc-string word exceptions t)
+ (setcar (assoc-string word exceptions t) word)
+ (push (cons word t) exceptions))
+ exceptions)
+
+(defun wisi-case-create-exception (&optional partial)
+ "Define a word as an auto-casing exception in the current project.
+The word is the active region, or the symbol at point. If
+PARTIAL is non-nil, create a partial word exception. User is
+prompted to choose a file from the project case-exception-files
+if it is a list."
+ (interactive)
+ (let* ((project (wisi-prj-require-prj))
+ (file-name
+ (cond
+ ((< 1 (length (wisi-prj-case-exception-files project)))
+ (completing-read "case exception file: "
(wisi-prj-case-exception-files project)
+ nil ;; predicate
+ t ;; require-match
+ nil ;; initial-input
+ nil ;; hist
+ (car (wisi-prj-case-exception-files project)) ;;
default
+ ))
+
+ ((= 1 (length (wisi-prj-case-exception-files project)))
+ (car (wisi-prj-case-exception-files project)))
+
+ (t
+ (error "No exception file specified; set `casing' in project
file."))
+ ))
+ word)
+
+ (if (use-region-p)
+ (progn
+ (setq word (buffer-substring-no-properties (region-beginning)
(region-end)))
+ (deactivate-mark))
+ (save-excursion
+ (let ((syntax (if partial "w" "w_")))
+ (skip-syntax-backward syntax)
+ (setq word
+ (buffer-substring-no-properties
+ (point)
+ (progn (skip-syntax-forward syntax) (point))
+ )))))
+
+ (let* ((exceptions (wisi--case-read-exceptions file-name))
+ (file-full-exceptions (car exceptions))
+ (file-partial-exceptions (cdr exceptions)))
+
+ (cond
+ ((null partial)
+ (setf (wisi-prj-case-full-exceptions project)
+ (wisi--case-add-exception word (wisi-prj-case-full-exceptions
project)))
+ (setq file-full-exceptions (wisi--case-add-exception word
file-full-exceptions)))
+
+ (t
+ (setf (wisi-prj-case-partial-exceptions project)
+ (wisi--case-add-exception word (wisi-prj-case-partial-exceptions
project)))
+ (setq file-partial-exceptions (wisi--case-add-exception word
file-partial-exceptions)))
+
+ )
+ (wisi--case-save-exceptions file-full-exceptions file-partial-exceptions
file-name)
+ (message "created %s case exception '%s' in file '%s'"
+ (if partial "partial" "full")
+ word
+ file-name)
+ )
+ ))
+
+(defun wisi-case-create-partial-exception ()
+ "Define active region or word at point as a partial word exception.
+User is prompted to choose a file from the project
+case-exception-files if it is a list."
+ (interactive)
+ (wisi-case-create-exception t))
+
+(defun wisi-after-keyword-p ()
+ "Return non-nil if point is after an element of `wisi-language-keywords'."
+ (let ((word (buffer-substring-no-properties
+ (save-excursion (skip-syntax-backward "w_") (point))
+ (point))))
+ (member (downcase word) wisi-language-keywords)))
+
+(defvar-local wisi--ret-binding #'wisi-indent-newline-indent)
+(defvar-local wisi--lfd-binding #'newline-and-indent)
+
+(defun wisi-case-keyword (beg end)
+ (cl-ecase wisi-case-keyword
+ (lower-case (downcase-region beg end))
+ (upper-case (upcase-region beg end))
+ ))
+
+(defun wisi-case-identifier (start end case-strict)
+ (cl-ecase wisi-case-identifier
+ (mixed-case (wisi-mixed-case start end case-strict))
+ (lower-case (downcase-region start end))
+ (upper-case (upcase-region start end))
+ ))
+
+(defun wisi-mixed-case (start end case-strict)
+ "Adjust case of region START END to Mixed_Case."
+ (let ((done nil)
+ next)
+ (if (or case-strict wisi-case-strict)
+ (downcase-region start end))
+ (goto-char start)
+ (while (not done)
+ (setq next
+ (or
+ (save-excursion (when (search-forward "_" end t) (point-marker)))
+ (copy-marker (1+ end))))
+
+ ;; upcase first char
+ (upcase-region (point) (1+ (point)))
+
+ (goto-char next)
+ (if (< (point) end)
+ (setq start (point))
+ (setq done t))
+ )))
+
+(defun wisi-case-adjust-identifier (&optional force-case)
+ "Adjust case of the previous word as an identifier.
+Uses `wisi-case-identifier', with exceptions defined in
+`wisi-case-full-exceptions', `wisi-case-partial-exceptions'. If
+force-case non-nil (default prefix), treat `wisi-strict-case' as
+t."
+ (interactive "P")
+ (save-excursion
+ ;; We don't complain when there is no project; we may be editing a
+ ;; random Ada file.
+ (let ((prj (wisi-prj-current-prj))
+ (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)
+ (wisi-prj-case-full-exceptions prj)
+ t ;; case-fold
+ ))
+ ;; 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 wisi-case-identifier
+ (wisi-case-identifier start end force-case)
+
+ ;; apply partial-exceptions
+ (goto-char start)
+ (while (not done)
+ (setq next
+ (or
+ (save-excursion (when (search-forward "_" end t)
(point-marker)))
+ (copy-marker (1+ end))))
+
+ (when (setq match (assoc-string (buffer-substring-no-properties start
(1- next))
+ (wisi-prj-case-partial-exceptions prj)
+ t))
+ ;; see comment above at 'full word exception' for why
+ ;; we do insert first.
+ (insert (car match))
+ (delete-region (point) (1- next)))
+
+ (goto-char next)
+ (if (< (point) end)
+ (setq start (point))
+ (setq done t))
+ ))
+ )))
+
+(defun wisi-case-adjust-keyword ()
+ "Adjust the case of the previous symbol as a keyword."
+ (save-excursion
+ (let ((end (point-marker))
+ (start (progn (skip-syntax-backward "w_") (point))))
+ (wisi-case-keyword start end)
+ )))
+
+(defun wisi-case-adjust (&optional typed-char in-comment)
+ "Adjust the case of the symbol before point.
+When invoked interactively, TYPED-CHAR must be
+`last-command-event', and it must not have been inserted yet. If
+IN-COMMENT is non-nil, adjust case of words in comments and
+strings as code, and treat `wisi-case-strict' as t in code."
+ (when (not (bobp))
+ (when (save-excursion
+ (forward-char -1); back to last character in symbol
+ (and (not (bobp))
+ (eq (char-syntax (char-after)) ?w); it can be capitalized
+
+ (or in-comment
+ (not (wisi-in-string-or-comment-p)))
+
+ (or (null wisi-case-adjust-p-function)
+ (funcall wisi-case-adjust-p-function typed-char))
+ ))
+
+ ;; The indentation engine may trigger a reparse on
+ ;; non-whitespace changes, but we know we don't need to reparse
+ ;; for this change (assuming the user has not abused case
+ ;; exceptions!).
+ (let ((inhibit-modification-hooks t))
+ (cond
+ ;; Some attributes are also keywords, but captialized as
+ ;; attributes. So check for attribute first.
+ ((and
+ (not in-comment)
+ (save-excursion
+ (skip-syntax-backward "w_")
+ (eq (char-before) ?')))
+ (wisi-case-adjust-identifier in-comment))
+
+ ((and
+ (not in-comment)
+ (not (eq typed-char ?_))
+ (wisi-after-keyword-p))
+ (wisi-case-adjust-keyword))
+
+ (t (wisi-case-adjust-identifier in-comment))
+ ))
+ )))
+
+(defun wisi-case-adjust-at-point (&optional in-comment)
+ "If ’wisi-auto-case’ is non-nil, adjust case of symbol at point.
+Also move to end of symbol. With prefix arg, adjust case as code
+even if in comment or string; otherwise, capitalize words in
+comments and strings. If ’wisi-auto-case’ is nil, capitalize
+current word."
+ (interactive "P")
+ (cond
+ ((or (null wisi-auto-case)
+ (and (not in-comment)
+ (wisi-in-string-or-comment-p)))
+ (skip-syntax-backward "w_")
+ (capitalize-word 1))
+
+ (t
+ (when
+ (and (not (eobp))
+ ;; We use '(syntax-after (point))' here, not '(char-syntax
+ ;; (char-after))', because the latter does not respect
+ ;; syntax-propertize functions
+ (memq (syntax-class (syntax-after (point))) '(2 3)))
+ (skip-syntax-forward "w_"))
+ (wisi-case-adjust nil in-comment))
+ ))
+
+(defun wisi-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_")
+ (wisi-case-adjust)))
+ (widen))
+
+(defun wisi-case-adjust-buffer ()
+ "Adjust case of current buffer."
+ (interactive)
+ (wisi-case-adjust-region (point-min) (point-max)))
+
+(defun wisi-case-adjust-interactive (arg)
+ "If `wisi-auto-case' is non-nil, adjust the case of the previous symbol,
+and process the character just typed. To be bound to keys that
+should cause auto-casing. ARG is the prefix the user entered
+with \\[universal-argument]."
+ (interactive "P")
+
+ ;; Character typed has not been inserted yet.
+ (let ((lastk last-command-event)
+ (do-adjust nil))
+ (cond
+ ((null wisi-auto-case))
+ (t
+ (setq do-adjust t)))
+
+ (cond
+ ((eq lastk ?\n)
+ (when do-adjust
+ (wisi-case-adjust lastk))
+ (funcall wisi--lfd-binding))
+
+ ((memq lastk '(?\r return))
+ (when do-adjust
+ (wisi-case-adjust lastk))
+ (funcall wisi--ret-binding))
+
+ (t
+ (when do-adjust
+ (wisi-case-adjust lastk))
+ (self-insert-command (prefix-numeric-value arg)))
+ )))
+
+(defun wisi-case-activate-keys (map)
+ "Modify the key bindings for all the keys that should adjust casing."
+ (mapc (function
+ (lambda(key)
+ (define-key
+ map
+ (char-to-string key)
+ 'wisi-case-adjust-interactive)))
+ '( ?_ ?% ?& ?* ?\( ?\) ?- ?= ?+
+ ?| ?\; ?: ?' ?\" ?< ?, ?. ?> ?/ ?\n 32 ?\r ))
+ )
+
+;;;; xref backend
+
+(cl-defmethod xref-backend-definitions ((prj wisi-prj) identifier)
+ (wisi-xref-definitions (wisi-prj-xref prj) prj (wisi-xref-item identifier)))
+
+(cl-defmethod xref-backend-identifier-at-point ((prj wisi-prj))
+ (save-excursion
+ (condition-case nil
+ (let ((ident (wisi-prj-identifier-at-point prj))) ;; moves point to
start of ident
+ (put-text-property
+ 0 1
+ 'xref-identifier
+ (list ':file (buffer-file-name)
+ ':line (line-number-at-pos)
+ ':column (current-column))
+ ident)
+ ident)
+ (error
+ ;; from wisi-prj-identifier-at-point; no identifier
+ nil))))
+
+(cl-defmethod xref-backend-identifier-completion-table ((_prj wisi-prj))
+ ;; Current buffer only.
+ (wisi-names nil))
+
+(cl-defmethod xref-backend-references ((prj wisi-prj) identifier)
+ (wisi-xref-references (wisi-prj-xref prj) prj (wisi-xref-item identifier)))
+
+;;;###autoload
+(defun wisi-prj-xref-backend ()
+ "For `xref-backend-functions'; return the current wisi project."
+ ;; We return the project, not the xref object, because the
+ ;; wisi-xref-* functions need the project.
+ (let ((prj (project-current)))
+ (when (wisi-prj-p prj)
+ prj)))
+
+;;;; project-find-functions alternatives
+
+(defvar wisi-prj--dominating-alist nil
+"Alist of (DOMINATING-FILE . PRJ-FILE-NAME): DOMINATING-FILE is
+an absolute filename that can be found by
+`wisi-prj-find-dominating-cached' or
+`wisi-prj-find-dominating-cached'. PRJ-FILE-NAME is the wisi
+project file for the project for that file.")
+
+;;;###autoload
+(defun wisi-prj-select-cache (prj-file init-prj &optional dominating-file)
+ "Select project matching PRJ-FILE in `wisi-prj--cache' as current project,
+parsing and caching if needed. Also add DOMINATING-FILE (default
+current buffer file name) to `wisi-prj--dominating-alist' (for
+`wisi-prj-select-dominating'.)"
+ (let ((old-prj (project-current)))
+ ;; If old-prj is not a wisi-prj, we don't know how to deselect it;
+ ;; just ignore that. If prj-file is the current file, user is
+ ;; re-selecting it.
+ (when (wisi-prj-p old-prj)
+ (wisi-prj-deselect old-prj)))
+
+ (unless (or (memq #'wisi-prj-current-cached project-find-functions)
+ (memq #'wisi-prj-current-cached (default-value
'project-find-functions)))
+ (message "wisi-prj-select-cache used without wisi-prj-current-cached in
project-find-functions"))
+
+ (setq dominating-file (if dominating-file (expand-file-name dominating-file)
(buffer-file-name)))
+ (setq prj-file (expand-file-name prj-file))
+ (add-to-list 'wisi-prj--dominating-alist (cons dominating-file prj-file))
+
+ (let ((new-prj (cdr (assoc prj-file wisi-prj--cache))))
+ (unless new-prj
+ (setq new-prj (wisi-prj-parse-file :prj-file prj-file :init-prj init-prj
:cache t))
+ (unless new-prj
+ (error "parsing project file '%s' failed" prj-file)))
+
+ (setq wisi-prj--current-file prj-file)
+ (wisi-prj-select new-prj)))
+
+;;;###autoload
+(defun wisi-prj-select-dominating (&optional dominating-file)
+ "Unless it is already current, select a wisi-prj matching DOMINATING-FILE.
+DOMINATING-FILE defaults to the current buffer file name.
+Useful before running `compilation-start', to ensure the correct
+project is current."
+ (when (or dominating-file (buffer-file-name))
+ ;; buffer-file-name is nil in *compilation* buffer
+ (let ((prj-file (cdr (assoc (or dominating-file (buffer-file-name))
wisi-prj--dominating-alist))))
+ (unless (string-equal prj-file wisi-prj--current-file)
+ (message "Switching to project file '%s'" prj-file)
+ (let ((old-prj (cdr (assoc wisi-prj--current-file wisi-prj--cache)))
+ (new-prj (cdr (assoc prj-file wisi-prj--cache))))
+ (when (wisi-prj-p old-prj)
+ (wisi-prj-deselect old-prj))
+ (when (wisi-prj-p new-prj)
+ (wisi-prj-select new-prj))
+ (setq wisi-prj--current-file prj-file))))))
+
+;;;###autoload
+(defun wisi-prj-current-cached (_dir)
+ "For `project-find-functions'; return the current project from
`wisi-prj--cache'."
+ (cdr (assoc wisi-prj--current-file wisi-prj--cache)))
+
+(defvar wisi-prj--default nil
+ "Alist of (PRJ-FILE . INIT-PRJ), for `wisi-prj-parse-current'.
+PRJ-FILE is an absolute project file name; INIT-PRJ is the
+initial `wisi-prj' object for that project file.")
+
+;;;###autoload
+(defun wisi-prj-select-file (prj-file default-prj &optional dominating-file)
+ "Set PRJ-FILE as current project, add DEFAULT-PRJ to `wisi-prj--default'.
+Also add DOMINATING-FILE (default current buffer file name) to
+`wisi-prj--dominating-alist' (for `wisi-prj-select-dominating'.)"
+ (unless (or (memq #'wisi-prj-current-parse project-find-functions)
+ (memq #'wisi-prj-current-parse (default-value
'project-find-functions)))
+ (message "wisi-prj-select-file used without wisi-prj-current-parse in
project-find-functions"))
+
+ (setq dominating-file (if dominating-file (expand-file-name dominating-file)
(buffer-file-name)))
+ (setq prj-file (expand-file-name prj-file))
+ (add-to-list 'wisi-prj--dominating-alist (cons dominating-file prj-file))
+ (setq wisi-prj--current-file prj-file)
+ (add-to-list 'wisi-prj--default (cons prj-file default-prj)))
+
+;;;###autoload
+(defun wisi-prj-current-parse (_dir)
+ "For `project-find-functions'; parse the current project file, select and
return the project"
+ (let ((prj (wisi-prj-parse-file
+ :prj-file wisi-prj--current-file
+ :init-prj (cdr (assoc-string wisi-prj--current-file
wisi-prj--default))
+ :cache nil)))
+ (wisi-prj-select prj)
+ prj))
+
+(defvar wisi-prj--dominating nil
+ "List of relative filenames for `wisi-prj-find-dominating-cached'
+and `wisi-prj-find-dominating-parse'. Set by `wisi-prj-set-dominating'.")
+
+(defun wisi-prj-reset-cache ()
+ "Delete all wisi project cached info."
+ (interactive)
+ (setq wisi-prj--cache nil)
+ (setq wisi-prj--current-file nil)
+ (setq wisi-prj--default nil)
+ (setq wisi-prj--dominating nil)
+ (setq wisi-prj--dominating-alist nil))
+
+;;;###autoload
+(defun wisi-prj-cache-dominating (prj-file default-prj &optional
dominating-file)
+ "Parse prj-file, add to `wisi-prj--cache'.
+Also add (DOMINATING-FILE . PRJ-FILE) to `wisi-prj--dominating-alist'.
+DOMINATING-FILE defaults to (buffer-file-name). "
+ (unless (or (memq #'wisi-prj-find-dominating-cached project-find-functions)
+ (memq #'wisi-prj-find-dominating-cached (default-value
'project-find-functions)))
+ (message "wisi-prj-cache-dominating used without
wisi-prj-find-dominating-cached in project-find-functions"))
+
+ (setq dominating-file (if dominating-file (expand-file-name dominating-file)
(buffer-file-name)))
+ (setq prj-file (expand-file-name prj-file))
+ (add-to-list 'wisi-prj--dominating (file-name-nondirectory dominating-file))
+ (add-to-list 'wisi-prj--dominating-alist (cons dominating-file prj-file))
+ (wisi-prj-parse-file :prj-file prj-file :init-prj default-prj :cache t)
+ nil)
+
+(defun wisi-prj--find-dominating-file (start-dir)
+ "Return the project file matching `wisi-prj--dominating'."
+ (let* (dom-file
+ (_dom-dir
+ (locate-dominating-file
+ start-dir
+ (lambda (dir)
+ (let ((names wisi-prj--dominating))
+ (while names
+ (let ((filename (expand-file-name (pop names) dir)))
+ (when (file-exists-p filename)
+ (setq dom-file filename)
+ (setq names nil)))))
+ dom-file))))
+ (cdr (assoc-string dom-file wisi-prj--dominating-alist))))
+
+;;;###autoload
+(defun wisi-prj-find-dominating-cached (dir)
+ "For `project-find-functions'; return the cached project
+matching `wisi-prj--dominating' (nil if none). Select it if it is
+not the current project."
+ (let* ((prj-file (wisi-prj--find-dominating-file dir))
+ (new-prj (cdr (assoc-string prj-file wisi-prj--cache))))
+ (when prj-file
+ (unless (string= prj-file wisi-prj--current-file)
+ (let ((old-prj (cdr (assoc-string wisi-prj--current-file
wisi-prj--cache))))
+ (when old-prj (wisi-prj-deselect old-prj))
+ (unless new-prj
+ ;; User may have used `wisi-prj-set-dominating' instead of
+ ;; `wisi-prj-cache-dominating'; parse the project file now.
+ (wisi-prj-parse-file
+ :prj-file prj-file
+ :init-prj (cdr (assoc-string prj-file wisi-prj--default))
+ :cache t))
+ (when new-prj (wisi-prj-select new-prj))))
+ new-prj)))
+
+;;;###autoload
+(defun wisi-prj-set-dominating (prj-file default-prj &optional dom-file)
+ "Add (DOM-FILE . PRJ-FILE) to `wisi-prj--dominating-alist',
+and (PRJ-FILE . DEFAULT-PRJ) to `wisi-prj--default'.
+DOM-FILE defaults to (buffer-file-name).
+For example, call this in the Local Vars of a Makefile to
+associate a project with that Makefile."
+ (unless (or (memq #'wisi-prj-find-dominating-parse project-find-functions)
+ (memq #'wisi-prj-find-dominating-parse (default-value
'project-find-functions)))
+ (message "wisi-prj-cache-dominating used without
wisi-prj-find-dominating-parse in project-find-functions"))
+
+ (setq dom-file (if dom-file (expand-file-name dom-file) (buffer-file-name)))
+ (setq prj-file (expand-file-name prj-file))
+ (add-to-list 'wisi-prj--dominating (file-name-nondirectory dom-file))
+ (add-to-list 'wisi-prj--dominating-alist (cons dom-file prj-file))
+ (add-to-list 'wisi-prj--default (cons prj-file default-prj))
+ nil)
+
+;;;###autoload
+(defun wisi-prj-find-dominating-parse (dir)
+ "For `project-find-functions'; parse, select, and return the project
+file matching `wisi-prj--dominating'."
+ (let ((prj-file (wisi-prj--find-dominating-file dir)))
+ (when prj-file
+ (let ((prj (wisi-prj-parse-file
+ :prj-file prj-file
+ :init-prj (cdr (assoc-string prj-file wisi-prj--default))
+ :cache nil)))
+ (wisi-prj-select prj)
+ prj))))
+
+;;;###autoload
+(defun wisi-prj-dtrt-parse-file (prj-file default-prj dominating-file
&optional dir)
+ "Depending on wisi-prj function in `project-find-functions',
+Do The Right Thing to make PRJ-FILE active and selected; return the project."
+ (cond
+ ((memq #'wisi-prj-find-dominating-parse project-find-functions)
+ (wisi-prj-set-dominating prj-file default-prj dominating-file))
+
+ ((memq #'wisi-prj-find-dominating-cached project-find-functions)
+ (wisi-prj-cache-dominating prj-file default-prj dominating-file))
+
+ ((memq #'wisi-prj-current-cached project-find-functions)
+ (wisi-prj-select-cache prj-file default-prj dominating-file))
+
+ ((memq #'wisi-prj-current-parse project-find-functions)
+ (wisi-prj-select-file prj-file default-prj dominating-file))
+
+ (t
+ (user-error "No wisi-prj function in project-find-functions"))
+ )
+ (project-current nil (or dir default-directory)))
+
+;;;###autoload
+(defun wisi-prj-find-function-set-p ()
+ "Return non-nil if a wisi-prj function is present in
`project-find-functions'."
+ (or (memq #'wisi-prj-find-dominating-parse project-find-functions)
+ (memq #'wisi-prj-find-dominating-cached project-find-functions)
+ (memq #'wisi-prj-current-cached project-find-functions)
+ (memq #'wisi-prj-current-parse project-find-functions)))
+
+;;;; project menu
+
+(defun wisi-prj--menu-compute ()
+ "Return an easy-menu menu for `wisi-prj-menu--install'.
+Menu displays cached wisi projects."
+ (let (menu)
+ (dolist (item wisi-prj--cache)
+ (push
+ (vector
+ (concat (wisi-prj-name (cdr item))
+ (when (equal (car item) wisi-prj--current-file) " *")) ;;
current project
+ `(lambda () (interactive)
+ (when wisi-prj--current-file
+ (wisi-prj-deselect (cdr (assoc wisi-prj--current-file
wisi-prj--cache))))
+ (setq wisi-prj--current-file ,(car item))
+ (wisi-prj-select ,(cdr item)))
+ t)
+ menu)
+ )
+ (nreverse menu)))
+
+(defun wisi-prj-menu-install ()
+ "Install the project menu if appropriate, to display cached wisi projects."
+ (when
+ (or (memq #'wisi-prj-find-dominating-cached project-find-functions)
+ (memq #'wisi-prj-current-cached project-find-functions))
+
+ (let ((menu (wisi-prj--menu-compute)))
+ (if menu
+ (define-key-after
+ global-map
+ [menu-bar wisi-prj-select]
+ (easy-menu-binding
+ (easy-menu-create-menu
+ "Wisi Prj Select";; EDE uses "Project" menu
+ menu))
+ (lookup-key global-map [menu-bar tools]))
+ ;; delete empty menu
+ (define-key-after
+ global-map
+ [menu-bar wisi-prj-select]
+ nil
+ (lookup-key global-map [menu-bar tools]))
+ ))
+ ))
+
+(add-hook 'menu-bar-update-hook 'wisi-prj-menu-install)
+
+(defun wisi-prj-completion-table ()
+ "Return list of names of cached projects."
+ (mapcar (lambda (item) (wisi-prj-name (cdr item))) wisi-prj--cache))
+
+(defun wisi-prj-delete (name)
+ "Delete project NAME (default prompt) from the cached projects."
+ (interactive (list (completing-read "project name: "
(wisi-prj-completion-table))))
+ (let (pair)
+ (dolist (item wisi-prj--cache)
+ (if (string= name (wisi-prj-name (cdr item)))
+ (setq pair item)))
+
+ (setq wisi-prj--cache (delete pair wisi-prj--cache))
+
+ (setq wisi-prj--dominating-alist
+ (cl-delete-if (lambda (item)
+ (string= (car pair) (cdr item)))
+ wisi-prj--dominating-alist))
+ ))
+
+(provide 'wisi-prj)
+;; end wisi-prj.el
diff --git a/packages/wisi/wisi-process-parse.el
b/packages/wisi/wisi-process-parse.el
index 5fb025d..46abc92 100644
--- a/packages/wisi/wisi-process-parse.el
+++ b/packages/wisi/wisi-process-parse.el
@@ -1,6 +1,6 @@
;;; wisi-process-parse.el --- interface to external parse program
;;
-;; Copyright (C) 2014, 2017 - 2019 Free Software Foundation, Inc.
+;; Copyright (C) 2014, 2017 - 2020 Free Software Foundation, Inc.
;;
;; Author: Stephen Leake <address@hidden>
;;
@@ -31,10 +31,10 @@
is no response from the parser after waiting this amount (in
seconds)."
:type 'float
- :safe 'floatp)
+ :safe 'numberp)
(make-variable-buffer-local 'wisi-process-time-out)
-(defconst wisi-process-parse-protocol-version "4"
+(defconst wisi-process-parse-protocol-version "5"
"Defines data exchanged between this package and the background process.
Must match emacs_wisi_common_parse.ads Protocol_Version.")
@@ -83,7 +83,8 @@ Otherwise add PARSER to ‘wisi-process--alist’, return it."
(let ((exec-file (locate-file (wisi-process--parser-exec-file parser)
exec-path '("" ".exe"))))
(unless exec-file
- (error "%s not found on `exec-path'" (wisi-process--parser-exec-file
parser)))
+ (error "%s not found on `exec-path'; run 'build.sh' in the ELPA
package."
+ (wisi-process--parser-exec-file parser)))
(push (cons (wisi-process--parser-label parser) parser)
wisi-process--alist)
@@ -225,7 +226,7 @@ PARSE-END, wait for command to complete. PARSER will
respond with
one or more Edit messages."
;; Must match "refactor" command arguments read by
;; emacs_wisi_common_parse.adb Get_Refactor_Params.
- (let* ((cmd (format "refactor %d \"%s\" %d %d %d %d %d %d %d %d %d %d %d"
+ (let* ((cmd (format "refactor %d \"%s\" %d %d %d %d %d %d %d %d %d %d %d %d"
refactor-action
(if (buffer-file-name) (file-name-nondirectory
(buffer-file-name)) "")
(position-bytes parse-begin)
@@ -234,6 +235,7 @@ one or more Edit messages."
parse-begin ;; char_pos
(line-number-at-pos parse-begin)
(line-number-at-pos parse-end)
+ (save-excursion (goto-char parse-begin)
(back-to-indentation) (current-column));; indent-begin
(if (> wisi-debug 0) 1 0) ;; debug-mode
(1- wisi-debug) ;; trace_parse
wisi-trace-action
@@ -396,7 +398,7 @@ complete."
(cl-do ((i 1 (1+ i))) ((= i (length sexp)))
(push
(make-wisi--parse-error-repair
- :pos (aref (aref sexp i) 0)
+ :pos (copy-marker (aref (aref sexp i) 0))
:inserted (mapcar (lambda (id) (aref token-table id)) (aref (aref
sexp i) 1))
:deleted (mapcar (lambda (id) (aref token-table id)) (aref (aref
sexp i) 2))
:deleted-region (aref (aref sexp i) 3))
@@ -406,7 +408,7 @@ complete."
(defun wisi-process-parse--End (parser sexp)
;; sexp is [End pos]
;; see ‘wisi-process-parse--execute’
- (setf (wisi-process--parser-end-pos parser) (aref sexp 1)))
+ (setf (wisi-process--parser-end-pos parser) (1+ (aref sexp 1))))
(defun wisi-process-parse--Edit (parser sexp)
;; sexp is [Edit begin end text]
@@ -703,7 +705,7 @@ complete."
(when (and (= (point-max) need-more)
(> (wisi-process--parser-total-wait-time parser)
wisi-process-time-out))
- (error "wisi-process-parse not getting more text (or bad syntax
in process output)"))
+ (error "wisi-process-parse timing out; increase
`wisi-process-time-out'? (or bad syntax in process output)"))
(setq need-more nil))
);; while not done
diff --git a/packages/wisi/wisi-run-indent-test.el
b/packages/wisi/wisi-run-indent-test.el
index fcf0b33..269b3d9 100644
--- a/packages/wisi/wisi-run-indent-test.el
+++ b/packages/wisi/wisi-run-indent-test.el
@@ -1,6 +1,6 @@
;;; wisi-run-indent-test.el --- utils for automating indentation and casing
tests
;;
-;; Copyright (C) 2018 - 2019 Free Software Foundation, Inc.
+;; Copyright (C) 2018 - 2020 Free Software Foundation, Inc.
;;
;; This file is part of GNU Emacs.
;;
@@ -18,6 +18,7 @@
;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
(require 'wisi-tests)
+(require 'wisi-prj)
;; user can set these to t in an EMACSCMD
(defvar skip-cmds nil)
@@ -170,6 +171,11 @@ Each item is a list (ACTION PARSE-BEGIN PARSE-END
EDIT-BEGIN)")
(setq indent-tabs-mode nil)
(setq jit-lock-context-time 0.0);; for test-face
+ ;; Test files use wisi-prj-select-cached to parse and select a project file.
+ (setq project-find-functions (list #'wisi-prj-current-cached))
+ (setq xref-backend-functions (list #'wisi-prj-xref-backend))
+
+
(let ((error-count 0)
(test-buffer (current-buffer))
cmd-line
@@ -185,6 +191,11 @@ Each item is a list (ACTION PARSE-BEGIN PARSE-END
EDIT-BEGIN)")
;; of the previous EMACSCMD, and the test fails if they don't
;; match.
;;
+ ;; EMACSRESULT_START:<first list element>
+ ;; EMACSRESULT_ADD: <list element>
+ ;; EMACSRESULT_FINISH:
+ ;; build a list, compare it to the result of the previous EMACSCMD.
+ ;;
;; EMACS_SKIP_UNLESS: <form>
;; skip entire test if form evals nil
;;
@@ -223,7 +234,6 @@ Each item is a list (ACTION PARSE-BEGIN PARSE-END
EDIT-BEGIN)")
(looking-at ".*$")
(setq expected-result (save-excursion (end-of-line 1) (eval (car
(read-from-string (match-string 0))))))
(unless (equal expected-result last-result)
- (when debug-on-error (debug))
(setq error-count (1+ error-count))
(message
(concat
@@ -234,6 +244,43 @@ Each item is a list (ACTION PARSE-BEGIN PARSE-END
EDIT-BEGIN)")
expected-result)
))))
+ ((string= (match-string 1) "RESULT_START")
+ (looking-at ".*$")
+ (setq expected-result (list (save-excursion (end-of-line 1) (eval (car
(read-from-string (match-string 0))))))))
+
+ ((string= (match-string 1) "RESULT_ADD")
+ (looking-at ".*$")
+ (let ((val (save-excursion (end-of-line 1)
+ (eval (car (read-from-string (match-string
0)))))))
+ (when val
+ (setq expected-result (append expected-result (list val))))))
+
+ ((string= (match-string 1) "RESULT_FINISH")
+ (unless (equal (length expected-result) (length last-result))
+ (setq error-count (1+ error-count))
+ (message
+ (concat
+ (format "error: %s:%d:\n" (buffer-file-name) (line-number-at-pos))
+ (format "Length of result of '%s' does not match.\nGot
'%s',\nexpect '%s'"
+ last-cmd
+ (length last-result)
+ (length expected-result)))))
+
+ (let ((i 0))
+ (while (< i (length expected-result))
+ (unless (equal (nth i expected-result) (nth i last-result))
+ (setq error-count (1+ error-count))
+ (message
+ (concat
+ (format "error: %s:%d:\n" (buffer-file-name)
(line-number-at-pos))
+ (format "Nth (%d) result of '%s' does not match.\nGot
'%s',\nexpect '%s'"
+ i
+ last-cmd
+ (nth i last-result)
+ (nth i expected-result))
+ )))
+ (setq i (1+ i)))))
+
((string= (match-string 1) "_SKIP_UNLESS")
(looking-at ".*$")
(unless (eval (car (read-from-string (match-string 0))))
@@ -261,7 +308,7 @@ Each item is a list (ACTION PARSE-BEGIN PARSE-END
EDIT-BEGIN)")
(buffer-file-name) (line-number-at-pos (point)) error-count))
)
- (when (not skip-reindent-test)
+ (unless skip-reindent-test
;; Reindent the buffer
(message "indenting")
@@ -278,11 +325,18 @@ Each item is a list (ACTION PARSE-BEGIN PARSE-END
EDIT-BEGIN)")
;; files must be saved without any.
(delete-trailing-whitespace)
)
+
+ (when (and wisi-auto-case (not skip-recase-test))
+ (message "casing")
+ (wisi-case-adjust-buffer))
)
(defun run-test (file-name)
"Run an indentation and casing test on FILE-NAME."
(interactive "f")
+
+ (package-initialize) ;; for uniquify-files
+
;; we'd like to run emacs from a makefile as:
;;
;; emacs -Q --batch -l runtest.el -f run-test-here <filename>
@@ -304,14 +358,11 @@ Each item is a list (ACTION PARSE-BEGIN PARSE-END
EDIT-BEGIN)")
;; that rely on font-lock do explicitly.
(setq font-lock-support-mode nil)
+ (setq xref-prompt-for-identifier nil)
+
(let ((dir default-directory))
(find-file file-name) ;; sets default-directory
- (when (eq major-mode 'fundamental-mode)
- ;; Running a grammar in test/wisi
- (add-to-list 'load-path (expand-file-name "."))
- (wisi-tests-setup (file-name-sans-extension (file-name-nondirectory
file-name))))
-
(run-test-here)
(unless skip-write
diff --git a/packages/wisi/wisi-skel.el b/packages/wisi/wisi-skel.el
new file mode 100644
index 0000000..96693fd
--- /dev/null
+++ b/packages/wisi/wisi-skel.el
@@ -0,0 +1,154 @@
+;;; wisi-skel.el --- Extensions skeleton -*- lexical-binding:t -*-
+
+;; Copyright (C) 1987, 1993, 1994, 1996-2019 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 `wisi-skel-expand', which inserts the
+;; skeleton associated with the previous word (possibly skipping a
+;; name).
+;;
+
+(defvar-local wisi-skel-token-alist nil
+ "Alist of (STRING . ELEMENT), used by `wisi-skel-expand'.
+STRING must be a symbol in the current syntax, and is normally
+the first language keyword in the skeleton.
+
+ELEMENT may be:
+- a skeleton, which is inserted
+- an alist of (STRING . SKELETON). User is prompted with `completing-read',
+ selected skeleton is inserted.")
+
+(defun wisi-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 " | ") " | ... : "))
+ ))
+
+(defvar wisi-skel-test-input nil
+ "Override prompt for input from wisi-skel-token-alist, for unit testing."
+ ;; see test/ada_skel.adb
+ )
+
+(defun wisi-skel-expand (&optional name)
+ "Expand the token or placeholder before point to a skeleton.
+Tokens are defined by `wisi-skel-token-alist'; they must have
+symbol syntax. A placeholder is a token enclosed in generic
+comment delimiters. If the symbol before point is not in
+`wisi-skel-token-alist', assume it is a name, and use the symbol
+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 " !>")
+
+ (let* ((wisi-inhibit-parse t) ;; don't parse until skeleton is fully inserted
+ (end (point))
+ ;; Include punctuation here, to handle a dotted name (ie Ada.Text_IO)
+ (token (progn (skip-syntax-backward "w_.")
+ (downcase (buffer-substring-no-properties (point) end))))
+ (skel (assoc-string token wisi-skel-token-alist))
+ (handled nil))
+
+ (if skel
+ (progn
+ (when (listp (cdr skel))
+ (let* ((alist (cdr skel))
+ (prompt (wisi-skel-build-prompt alist 4)))
+ (setq skel (assoc-string
+ (or wisi-skel-test-input (completing-read prompt
alist))
+ alist))
+ ))
+
+ ;; 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
+
+ (when wisi-auto-case
+ ;; Adjust case 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 (wisi-case-adjust-region (point) end)))
+
+ (wisi-skel-expand (buffer-substring-no-properties (point) end))
+ (setq handled t)))
+
+ (when (not handled)
+ (user-error "'%s' is not a skeleton token" name))
+ ))
+
+;;;###autoload
+(defun wisi-skel-hippie-try (old)
+ "For `hippie-expand-try-functions-list'."
+ (if old
+ ;; hippie is asking us to try the "next" completion; we don't have one
+ nil
+ (let ((pos (point))
+ (undo-len (if (eq 't pending-undo-list)
+ 0
+ (length pending-undo-list))))
+ (undo-boundary)
+ (condition-case nil
+ (progn
+ (wisi-skel-expand)
+ t)
+ (error
+ ;; undo hook action if any
+ (unless (or (eq 't pending-undo-list)
+ (= undo-len (length pending-undo-list)))
+ (undo))
+
+ ;; undo motion
+ (goto-char pos)
+ nil)))))
+
+(defun wisi-skel-next-placeholder ()
+ "Move point to after next placeholder."
+ (interactive)
+ (skip-syntax-forward "^!")
+ (skip-syntax-forward "w_!"))
+
+(defun wisi-skel-prev-placeholder ()
+ "Move point to after previous placeholder."
+ (interactive)
+ (skip-syntax-backward "^!"))
+
+(provide 'wisi-skel)
+;;; wisi-skel.el ends here
diff --git a/packages/wisi/wisi.adb b/packages/wisi/wisi.adb
index 1ba7a4f..227c45c 100644
--- a/packages/wisi/wisi.adb
+++ b/packages/wisi/wisi.adb
@@ -2,7 +2,7 @@
--
-- See spec.
--
--- Copyright (C) 2017 - 2019 Free Software Foundation, Inc.
+-- Copyright (C) 2017 - 2020 Free Software Foundation, Inc.
--
-- This library is free software; you can redistribute it and/or modify it
-- under terms of the GNU General Public License as published by the Free
@@ -95,7 +95,7 @@ package body Wisi is
Indent : in out Indent_Type)
with Pre => Delta_Indent.Label = Anchored
is begin
- -- [2] wisi-elisp-parse--apply-anchored; add Delta_Indent to Indent
+ -- Add Delta_Indent to Indent
case Indent.Label is
when Not_Set =>
@@ -130,7 +130,7 @@ package body Wisi is
procedure Indent_Apply_Int (Indent : in out Indent_Type; Offset : in
Integer)
is begin
- -- [2] wisi-elisp-parse--apply-int; add an Int indent to Indent
+ -- Add an Int indent to Indent
case Indent.Label is
when Not_Set =>
Indent := (Int, Offset);
@@ -255,8 +255,6 @@ package body Wisi is
Paren_Char_Pos : Buffer_Pos := Invalid_Buffer_Pos;
Text_Begin_Pos : Buffer_Pos := Invalid_Buffer_Pos;
begin
- -- [1] wisi-elisp-parse--paren-in-anchor-line. That uses elisp
syntax-ppss; here
- -- we search Terminals.
loop
declare
Tok : Augmented_Token renames Data.Terminals (I);
@@ -332,8 +330,8 @@ package body Wisi is
begin
if Cache.Face.Set then
Append (Line, Face_Property_Code);
- Append (Line, Buffer_Pos'Image (Cache.Region.First));
- Append (Line, Buffer_Pos'Image (Cache.Region.Last));
+ Append (Line, Buffer_Pos'Image (Cache.Char_Region.First));
+ Append (Line, Buffer_Pos'Image (Cache.Char_Region.Last));
Append (Line, Integer'Image (Cache.Face.Item));
Append (Line, ']');
Ada.Text_IO.Put_Line (To_String (Line));
@@ -644,7 +642,7 @@ package body Wisi is
Data.Terminals.Clear;
Data.Leading_Non_Grammar.Clear;
-- Data.Line_Begin_Pos set in Initialize, overwritten in
Lexer_To_Augmented
- -- Data.Line_Begin_Token ""
+ -- Data.Line_Begin_Token set in WisiToken.Parse.Next_Grammar_Token.
for S of Data.Line_Paren_State loop
S := 0;
@@ -1102,7 +1100,7 @@ package body Wisi is
(File_Name => Data.Lexer.File_Name,
Line => Name_Token.Line,
Column => Name_Token.Column,
- Message => "wisi-name-action: name set twice.");
+ Message => Trimmed_Image (Tree.Production_ID (Nonterm)) & ":
wisi-name-action: name set twice.");
else
Data.Name_Caches.Insert (Name_Token.Char_Region);
end if;
@@ -1116,7 +1114,6 @@ package body Wisi is
Tokens : in Syntax_Trees.Valid_Node_Index_Array;
Params : in Motion_Param_Array)
is
- -- [2] wisi-motion-action
use Navigate_Cache_Trees;
Start : Nil_Buffer_Pos := (Set => False);
@@ -1257,7 +1254,7 @@ package body Wisi is
Suf_Cache : Face_Cache_Type renames
Data.Face_Caches (Suffix_Cur);
begin
if Suffix = Suf_Cache.Class and
- Inside (Suf_Cache.Region.First,
Token.Char_Region)
+ Inside (Suf_Cache.Char_Region.First,
Token.Char_Region)
then
Suf_Cache.Face := (True, Param.Suffix_Face);
end if;
@@ -1284,8 +1281,6 @@ package body Wisi is
Params : in Face_Apply_Param_Array)
is
pragma Unreferenced (Nonterm);
-
- -- [2] wisi-face-apply-list-action
use Face_Cache_Trees;
Iter : constant Iterator := Data.Face_Caches.Iterate;
@@ -1299,7 +1294,7 @@ package body Wisi is
Cache_Cur := Find_In_Range (Iter, Ascending,
Token.Char_Region.First, Token.Char_Region.Last);
loop
exit when not Has_Element (Cache_Cur) or else
- Data.Face_Caches (Cache_Cur).Region.First >
Token.Char_Region.Last;
+ Data.Face_Caches (Cache_Cur).Char_Region.First >
Token.Char_Region.Last;
declare
Cache : Face_Cache_Type renames Data.Face_Caches
(Cache_Cur);
begin
@@ -1342,19 +1337,19 @@ package body Wisi is
declare
Cache : Face_Cache_Type renames Data.Face_Caches
(Cache_Cur);
Other_Cur : Cursor := Find_In_Range
- (Iter, Ascending, Cache.Region.Last + 1,
Token.Char_Region.Last);
+ (Iter, Ascending, Cache.Char_Region.Last + 1,
Token.Char_Region.Last);
Temp : Cursor;
begin
loop
exit when not Has_Element (Other_Cur) or else
- Data.Face_Caches (Other_Cur).Region.First >
Token.Char_Region.Last;
+ Data.Face_Caches (Other_Cur).Char_Region.First >
Token.Char_Region.Last;
Temp := Other_Cur;
Other_Cur := Next (Iter, Other_Cur);
Delete (Data.Face_Caches, Temp);
end loop;
- Cache.Class := Param.Class;
- Cache.Region.Last := Token.Char_Region.Last;
+ Cache.Class := Param.Class;
+ Cache.Char_Region.Last := Token.Char_Region.Last;
end;
else
Data.Face_Caches.Insert ((Token.Char_Region, Param.Class,
(Set => False)));
@@ -1372,8 +1367,6 @@ package body Wisi is
Params : in Face_Remove_Param_Array)
is
pragma Unreferenced (Nonterm);
-
- -- [2] wisi-face-remove-action
use Face_Cache_Trees;
Iter : constant Iterator := Data.Face_Caches.Iterate;
@@ -1388,7 +1381,7 @@ package body Wisi is
Cache_Cur := Find_In_Range (Iter, Ascending,
Token.Char_Region.First, Token.Char_Region.Last);
loop
exit when not Has_Element (Cache_Cur) or else
- Data.Face_Caches (Cache_Cur).Region.First >
Token.Char_Region.Last;
+ Data.Face_Caches (Cache_Cur).Char_Region.First >
Token.Char_Region.Last;
Temp := Cache_Cur;
Cache_Cur := Next (Iter, Cache_Cur);
Delete (Data.Face_Caches, Temp);
@@ -1459,7 +1452,6 @@ package body Wisi is
Ada.Text_IO.Put_Line (";; indent_action_0: " & Tree.Image (Nonterm,
Data.Descriptor.all));
end if;
- -- [2] wisi-indent-action
for I in Tokens'Range loop
if Tree.Byte_Region (Tokens (I)) /= Null_Buffer_Region and
I in Params'Range -- in some translated EBNF, not every token has
an indent param
@@ -1520,7 +1512,6 @@ package body Wisi is
is
use all type Syntax_Trees.Node_Label;
begin
- -- [2] wisi-indent-action*
for I in Tokens'First .. N loop
if Tree.Label (Tokens (I)) /= Virtual_Terminal and then
Get_Aug_Token (Data, Tree, Tokens (I)).First
@@ -1931,7 +1922,7 @@ package body Wisi is
Accumulate : in Boolean)
return Delta_Type
is
- -- [2] wisi-elisp-parse--anchored-2; return an anchored delta
+ -- Return an anchored delta
use Anchor_ID_Vectors;
-- We can't use a Reference here, because the Element in reference
-- types is constrained (as are all allocated objects of access
@@ -1987,7 +1978,7 @@ package body Wisi is
is
Indenting_Token : constant Aug_Token_Ref := Get_Aug_Token (Data, Tree,
Tree_Indenting);
begin
- -- [2] wisi-elisp-parse--indent-compute-delta, which evals
wisi-anchored*, wisi-hanging*.
+ -- Evaluate wisi-anchored*, wisi-hanging*.
case Param.Label is
when Simple =>
case Param.Param.Label is
@@ -2010,7 +2001,7 @@ package body Wisi is
begin
case Anchored_Label'(Param.Param.Label) is
when Anchored_0 =>
- -- [2] wisi-anchored, wisi-anchored-1
+ -- [2] wisi-anchored
return Indent_Anchored_2
(Data,
Anchor_Line => Anchor_Token.Line,
@@ -2115,10 +2106,55 @@ package body Wisi is
if Data.Indent_Comment_Col_0 then
declare
use all type Ada.Text_IO.Count;
- Indent : Boolean := True;
+
+ function Containing_Token return Base_Token_Index
+ is
+ -- Return token index of terminal containing non_grammer on
Line;
+ -- Invalid_Token_Index if none.
+ I : Line_Number_Type := Line;
+ J : Base_Token_Index;
+ begin
+ if Line < Data.Line_Begin_Token.First_Index then
+ -- Line is before first grammar token;
Leading_Non_Grammar checked
+ -- below.
+ return Invalid_Token_Index;
+ end if;
+
+ loop
+ exit when Data.Line_Begin_Token.all (I) /=
Augmented_Token_Arrays.No_Index;
+ -- No_Index means Line is in a multi-line token, which
could be a block comment.
+ I := I - 1;
+ end loop;
+
+ J := Data.Line_Begin_Token.all (I);
+ if Line in Data.Terminals (J).First_Trailing_Comment_Line ..
+ Data.Terminals (J).Last_Trailing_Comment_Line
+ then
+ return J;
+ else
+ return Invalid_Token_Index;
+ end if;
+ end Containing_Token;
+
+ Indent : Boolean := True;
+ Containing : constant Base_Token_Index := Containing_Token;
begin
- if Data.Line_Begin_Token.all (Line - 1) /=
Augmented_Token_Arrays.No_Index then
- for Tok of Data.Terminals (Data.Line_Begin_Token.all (Line -
1)).Non_Grammar loop
+ if Line < Data.Line_Begin_Token.First_Index then
+ -- Line is before the first grammar token. We may be doing
a partial
+ -- parse where the initial indent is non-zero, so we still
have to
+ -- check for column 0.
+ for Tok of Data.Leading_Non_Grammar loop
+ if Tok.Line = Line and then
+ Tok.ID in Data.First_Comment_ID .. Data.Last_Comment_ID
and then
+ Tok.Column = 0
+ then
+ Indent := False;
+ exit;
+ end if;
+ end loop;
+
+ elsif Containing /= Invalid_Token_Index then
+ for Tok of Data.Terminals (Containing).Non_Grammar loop
if Tok.Line = Line and then
Tok.ID in Data.First_Comment_ID .. Data.Last_Comment_ID
and then
Tok.Column = 0
diff --git a/packages/wisi/wisi.ads b/packages/wisi/wisi.ads
index d240f0a..f871888 100644
--- a/packages/wisi/wisi.ads
+++ b/packages/wisi/wisi.ads
@@ -10,7 +10,7 @@
--
-- [3] wisi-process-parse.el - defines elisp/process API
--
--- Copyright (C) 2017 - 2019 Free Software Foundation, Inc.
+-- Copyright (C) 2017 - 2020 Free Software Foundation, Inc.
--
-- This library is free software; you can redistribute it and/or modify it
-- under terms of the GNU General Public License as published by the Free
@@ -186,21 +186,17 @@ package Wisi is
----------
-- Indent
--
- -- elisp indent functions are represented by the Indent_Param type,
- -- not Ada functions. This is to get the execution time right; in
- -- elisp, the array of parameters to wisi-indent-action is not
- -- evaluated when wisi-indent-action is called; each parameter is
- -- evaluated by wisi-elisp-parse--indent-compute-delta.
+ -- Indent functions are represented by the Indent_Param type.
type Simple_Indent_Param_Label is -- not hanging
(None,
Int,
- Anchored_0, -- wisi-anchored
- Anchored_1, -- wisi-anchored%
- Anchored_2, -- wisi-anchored%-
- Anchored_3, -- wisi-anchored*
- Anchored_4, -- wisi-anchored*-
- Language -- language-specific function
+ Anchored_0, -- [2] wisi-anchored
+ Anchored_1, -- [2] wisi-anchored%
+ Anchored_2, -- [2] wisi-anchored%-
+ Anchored_3, -- [2] wisi-anchored*
+ Anchored_4, -- [2] wisi-anchored*-
+ Language -- [2] language-specific function
);
subtype Anchored_Label is Simple_Indent_Param_Label range Anchored_0 ..
Anchored_4;
@@ -250,10 +246,10 @@ package Wisi is
type Indent_Param_Label is
(Simple,
- Hanging_0, -- wisi-hanging
- Hanging_1, -- wisi-hanging-
- Hanging_2, -- wisi-hanging%
- Hanging_3 -- wisi-hanging%-
+ Hanging_0, -- [2] wisi-hanging
+ Hanging_1, -- [2] wisi-hanging-
+ Hanging_2, -- [2] wisi-hanging%
+ Hanging_3 -- [2] wisi-hanging%-
);
subtype Hanging_Label is Indent_Param_Label range Hanging_0 .. Hanging_3;
@@ -464,15 +460,15 @@ private
Nil : constant Nil_Buffer_Pos := (Set => False);
type Navigate_Cache_Type is record
- Pos : WisiToken.Buffer_Pos; -- implicit in wisi-cache
- Statement_ID : WisiToken.Token_ID; -- wisi-cache-nonterm
- ID : WisiToken.Token_ID; -- wisi-cache-token
- Length : Natural; -- wisi-cache-last
- Class : Navigate_Class_Type; -- wisi-cache-class
- Containing_Pos : Nil_Buffer_Pos; -- wisi-cache-containing
- Prev_Pos : Nil_Buffer_Pos; -- wisi-cache-prev
- Next_Pos : Nil_Buffer_Pos; -- wisi-cache-next
- End_Pos : Nil_Buffer_Pos; -- wisi-cache-end
+ Pos : WisiToken.Buffer_Pos; -- implicit in [1] wisi-cache
+ Statement_ID : WisiToken.Token_ID; -- [1] wisi-cache-nonterm
+ ID : WisiToken.Token_ID; -- [1] wisi-cache-token
+ Length : Natural; -- [1] wisi-cache-last
+ Class : Navigate_Class_Type; -- [1] wisi-cache-class
+ Containing_Pos : Nil_Buffer_Pos; -- [1] wisi-cache-containing
+ Prev_Pos : Nil_Buffer_Pos; -- [1] wisi-cache-prev
+ Next_Pos : Nil_Buffer_Pos; -- [1] wisi-cache-next
+ End_Pos : Nil_Buffer_Pos; -- [1] wisi-cache-end
end record;
function Key (Cache : in Navigate_Cache_Type) return WisiToken.Buffer_Pos
is (Cache.Pos);
@@ -500,12 +496,12 @@ private
end record;
type Face_Cache_Type is record
- Region : WisiToken.Buffer_Region;
- Class : Face_Class_Type;
- Face : Nil_Integer; -- not set, or index into *-process-faces-names
+ Char_Region : WisiToken.Buffer_Region;
+ Class : Face_Class_Type;
+ Face : Nil_Integer; -- not set, or index into
*-process-faces-names
end record;
- function Key (Cache : in Face_Cache_Type) return WisiToken.Buffer_Pos is
(Cache.Region.First);
+ function Key (Cache : in Face_Cache_Type) return WisiToken.Buffer_Pos is
(Cache.Char_Region.First);
package Face_Cache_Trees is new SAL.Gen_Unbounded_Definite_Red_Black_Trees
(Face_Cache_Type, WisiToken.Buffer_Pos);
@@ -514,8 +510,7 @@ private
package Anchor_ID_Vectors is new Ada.Containers.Vectors (Natural, Positive);
type Indent_Type (Label : Indent_Label := Not_Set) is record
- -- [2] wisi-elisp-parse--indent elements. Indent values may be
- -- negative while indents are being computed.
+ -- Indent values may be negative while indents are being computed.
case Label is
when Not_Set =>
null;
@@ -641,7 +636,6 @@ private
type Delta_Type (Label : Delta_Labels := Simple) is
record
- -- Matches DELTA input to wisi--indent-token-1
case Label is
when Simple =>
Simple_Delta : Simple_Delta_Type;
@@ -704,7 +698,6 @@ private
Offset : in Integer;
Accumulate : in Boolean)
return Delta_Type;
- -- [2] wisi-elisp-parse--anchored-2
function Indent_Compute_Delta
(Data : in out Parse_Data_Type'Class;
@@ -720,11 +713,11 @@ private
Indenting_Token : in Augmented_Token'Class;
Delta_Indent : in Delta_Type;
Indenting_Comment : in Boolean);
- -- [2] wisi-elisp-parse--indent-token-1. Sets Data.Indents, so caller
- -- may not be in a renames for a Data.Indents element.
+ -- Sets Data.Indents, so caller may not be in a renames for a
+ -- Data.Indents element.
-- Visible for language-specific children. Must match list in
- -- wisi-process-parse.el wisi-process-parse--execute.
+ -- [3] wisi-process-parse--execute.
Navigate_Cache_Code : constant String := "1";
Face_Property_Code : constant String := "2";
Indent_Code : constant String := "3";
diff --git a/packages/wisi/wisi.el b/packages/wisi/wisi.el
index a7a2fbf..6cdf2b5 100644
--- a/packages/wisi/wisi.el
+++ b/packages/wisi/wisi.el
@@ -1,13 +1,13 @@
;;; wisi.el --- Utilities for implementing an indentation/navigation engine
using a generalized LALR parser -*- lexical-binding:t -*-
;;
-;; Copyright (C) 2012 - 2019 Free Software Foundation, Inc.
+;; Copyright (C) 2012 - 2020 Free Software Foundation, Inc.
;;
;; Author: Stephen Leake <address@hidden>
;; Maintainer: Stephen Leake <address@hidden>
;; Keywords: parser
;; indentation
;; navigation
-;; Version: 2.2.1
+;; Version: 3.0.1
;; package-requires: ((emacs "25.0") (seq "2.20"))
;; URL: http://stephe-leake.org/ada/wisitoken.html
;;
@@ -127,11 +127,6 @@ deeply nested statement, but worse in some situations."
:group 'wisi
:safe 'integerp)
-(defvar wisi-inhibit-parse nil
- "When non-nil, don't run the parser.
-Language code can set this non-nil when syntax is known to be
-invalid temporarily, or when making lots of changes.")
-
(defcustom wisi-disable-face nil
"When non-nil, `wisi-setup' does not enable use of parser for font-lock.
Useful when debugging parser or parser actions."
@@ -145,6 +140,11 @@ Useful when debugging parser or parser actions."
(defvar wisi-error-buffer nil
"Buffer for displaying syntax errors.")
+(defvar wisi-inhibit-parse nil
+ "When non-nil, don't run the parser.
+Language code can set this non-nil when syntax is known to be
+invalid temporarily, or when making lots of changes.")
+
(defun wisi-safe-marker-pos (pos)
"Return an integer buffer position from POS, an integer or marker"
(cond
@@ -153,6 +153,61 @@ Useful when debugging parser or parser actions."
(t pos)))
+;;;; misc
+
+(defun wisi-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 wisi-pos-in-paren-p (pos)
+ "Return t if POS is inside a pair of parentheses."
+ (save-excursion
+ (> (nth 0 (syntax-ppss pos)) 0)))
+
+(defun wisi-same-paren-depth-p (pos1 pos2)
+ "Return t if POS1 is at same parentheses depth as POS2."
+ (= (nth 0 (syntax-ppss pos1)) (nth 0 (syntax-ppss pos2))))
+
+(defun wisi-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))))))
+
+(defun wisi-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 wisi-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 wisi-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 (wisi-in-string-p parse-result) (wisi-in-comment-p parse-result)))
+
+(defun wisi-indent-newline-indent ()
+ "insert a newline, indent the old and new lines."
+ (interactive "*")
+ ;; point may be in the middle of a word, so insert newline first,
+ ;; then go back and indent.
+ (insert "\n")
+ (unless (and (wisi-partial-parse-p (line-beginning-position)
(line-end-position))
+ (save-excursion (progn (forward-char -1)(looking-back
"begin\\|else" (line-beginning-position)))))
+ ;; Partial parse may think 'begin' is just the start of a
+ ;; statement, when it's actually part of a larger declaration. So
+ ;; don't indent 'begin'. Similarly for 'else'; error recovery will
+ ;; probably insert 'if then' immediately before it
+ (forward-char -1)
+ (funcall indent-line-function)
+ (forward-char 1))
+ (funcall indent-line-function))
+
;;;; token info cache
(defvar-local wisi-parse-failed nil
@@ -634,8 +689,10 @@ Used to ignore whitespace changes in before/after change
hooks.")
;; else show all errors in a ’compilation’ buffer
(setq wisi-error-buffer (get-buffer-create wisi-error-buffer-name))
- (let ((lexer-errs (nreverse (cl-copy-seq (wisi-parser-lexer-errors
wisi--parser))))
- (parse-errs (nreverse (cl-copy-seq (wisi-parser-parse-errors
wisi--parser))))
+ (let ((lexer-errs (sort (cl-copy-seq (wisi-parser-lexer-errors
wisi--parser))
+ (lambda (a b) (< (wisi--parse-error-pos a)
(wisi--parse-error-pos b)))))
+ (parse-errs (sort (cl-copy-seq (wisi-parser-parse-errors
wisi--parser))
+ (lambda (a b) (< (wisi--parse-error-pos a)
(wisi--parse-error-pos b)))))
(dir default-directory))
(with-current-buffer wisi-error-buffer
(setq window-size-fixed nil)
@@ -690,9 +747,7 @@ Usefull if the parser appears to be hung."
(interactive)
(wisi-parse-kill wisi--parser)
;; also force re-parse
- (dolist (parse-action '(face navigate indent))
- (wisi-set-parse-try t parse-action)
- (wisi-invalidate-cache parse-action (point-min)))
+ (wisi-reset-parser)
)
(defun wisi-partial-parse-p (begin end)
@@ -1029,6 +1084,18 @@ Return start cache."
(wisi-goto-end-1 cache))
))
+(defun wisi-goto-containing-statement-start ()
+ "Move point to the start of the statement containing the current statement."
+ (interactive)
+ (wisi-validate-cache (point-min) (point-max) t 'navigate)
+ (let ((cache (or (wisi-get-cache (point))
+ (wisi-backward-cache))))
+ (when cache
+ (setq cache (wisi-goto-start cache)))
+ (when cache
+ (setq cache (wisi-goto-containing cache nil)))
+ ))
+
(defun wisi-next-statement-cache (cache)
"Move point to CACHE-next, return cache; error if nil."
(when (not (markerp (wisi-cache-next cache)))
@@ -1096,6 +1163,27 @@ the comment on the previous line."
))
)))
+(defun wisi-indent-containing-statement ()
+ "Indent region given by `wisi-goto-containing-statement-start',
`wisi-cache-end'."
+ (interactive)
+ (wisi-validate-cache (point-min) (point-max) t 'navigate)
+
+ (save-excursion
+ (let ((cache (or (wisi-get-cache (point))
+ (wisi-backward-cache))))
+ (when cache
+ ;; can be nil if in header comment
+ (let ((start (progn
+ (setq cache (wisi-goto-containing (wisi-goto-start
cache)))
+ (point)))
+ (end (if (wisi-cache-end cache)
+ ;; nil when cache is statement-end
+ (wisi-cache-end cache)
+ (point))))
+ (indent-region start end)
+ ))
+ )))
+
(defvar-local wisi-indent-calculate-functions nil
"Functions to compute indentation special cases.
Called with point at current indentation of a line; return
@@ -1125,8 +1213,10 @@ Called with BEGIN END.")
(let ((col (current-column)))
(while (and (not (eobp))
(< (point) end))
- (forward-line 1)
- (indent-line-to col)
+ (if (= 1 (forward-line 1))
+ (indent-line-to col)
+ ;; on last line of buffer; terminate loop
+ (goto-char (point-max)))
(when (bobp)
;; single line in buffer; terminate loop
(goto-char (point-max))))))
@@ -1168,100 +1258,109 @@ for parse errors. BEGIN, END is the parsed region."
"For `indent-region-function', using the wisi indentation engine.
If INDENT-BLANK-LINES is non-nil, also indent blank lines (for use as
`indent-line-function')."
- (when (< 0 wisi-debug)
- (message "wisi-indent-region %d %d"
- (wisi-safe-marker-pos begin)
- (wisi-safe-marker-pos end)))
+ (if wisi-inhibit-parse
+ (when (< 0 wisi-debug)
+ (message "wisi-indent-region %d %d skipped; wisi-inhibit-parse"
+ (wisi-safe-marker-pos begin)
+ (wisi-safe-marker-pos end)))
- (let ((wisi--parse-action 'indent)
- (parse-required nil)
- (end-mark (copy-marker end))
- (prev-indent-failed wisi-indent-failed))
+ (let ((wisi--parse-action 'indent)
+ (parse-required nil)
+ (end-mark (copy-marker end))
+ (prev-indent-failed wisi-indent-failed))
- (wisi--check-change)
+ (when (< 0 wisi-debug)
+ (message "wisi-indent-region %d %d"
+ (wisi-safe-marker-pos begin)
+ (wisi-safe-marker-pos end)))
- ;; BEGIN is inclusive; END is exclusive.
- (save-excursion
- (goto-char begin)
- (setq begin (line-beginning-position))
-
- (when (bobp) (forward-line))
- (while (and (not parse-required)
- (or (and (= begin end) (= (point) end))
- (< (point) end))
- (not (eobp)))
- (unless (get-text-property (1- (point)) 'wisi-indent)
- (setq parse-required t))
- (forward-line))
- )
-
- ;; A parse either succeeds and sets the indent cache on all
- ;; lines in the parsed region, or fails and leaves valid caches
- ;; untouched.
- (when (and parse-required
- (or (not wisi-parse-failed)
- (wisi-parse-try 'indent)))
-
- (wisi-set-parse-try nil)
- (wisi--run-parse begin end)
-
- ;; If there were errors corrected, the indentation is
- ;; potentially ambiguous; see
- ;; test/ada_mode-interactive_2.adb. Or it was a partial parse,
- ;; where errors producing bad indent are pretty much expected.
- (unless (wisi-partial-parse-p begin end)
- (setq wisi-indent-failed (< 0 (+ (length (wisi-parser-lexer-errors
wisi--parser))
- (length (wisi-parser-parse-errors
wisi--parser))))))
- )
-
- (if wisi-parse-failed
- (progn
- ;; primary indent failed
- (setq wisi-indent-failed t)
- (when (functionp wisi-indent-region-fallback)
- (when (< 0 wisi-debug)
- (message "wisi-indent-region fallback"))
- (funcall wisi-indent-region-fallback begin end)))
+ (wisi--check-change)
+ ;; BEGIN is inclusive; END is exclusive.
(save-excursion
- ;; Apply cached indents.
(goto-char begin)
- (let ((wisi-indenting-p t))
- (while (and (not (eobp))
- (or (and (= begin end) (= (point) end))
- (< (point) end-mark))) ;; end-mark is exclusive
- (when (or indent-blank-lines (not (eolp)))
- ;; ’indent-region’ doesn’t indent an empty line; ’indent-line’
does
- (let ((indent (if (bobp) 0 (wisi--get-cached-indent begin end))))
- (indent-line-to indent))
- )
- (forward-line 1))
-
- ;; Run wisi-indent-calculate-functions
- (when wisi-indent-calculate-functions
- (goto-char begin)
- (while (and (not (eobp))
- (< (point) end-mark))
- (back-to-indentation)
- (let ((indent
- (run-hook-with-args-until-success
'wisi-indent-calculate-functions)))
- (when indent
- (indent-line-to indent)))
-
- (forward-line 1)))
- )
+ (setq begin (line-beginning-position))
+
+ (when (bobp) (forward-line))
+ (while (and (not parse-required)
+ (or (and (= begin end) (= (point) end))
+ (< (point) end))
+ (not (eobp)))
+ (unless (get-text-property (1- (point)) 'wisi-indent)
+ (setq parse-required t))
+ (forward-line))
+ )
- (when
- (and prev-indent-failed
- (not wisi-indent-failed))
- ;; Previous parse failed or indent was potentially
- ;; ambiguous, this one is not.
- (goto-char end-mark)
- (when (< 0 wisi-debug)
- (message "wisi-indent-region post-parse-fail-hook"))
- (run-hooks 'wisi-post-indent-fail-hook))
- ))
- ))
+ ;; A parse either succeeds and sets the indent cache on all
+ ;; lines in the parsed region, or fails and leaves valid caches
+ ;; untouched.
+ (when (and parse-required
+ (or (not wisi-parse-failed)
+ (wisi-parse-try 'indent)))
+
+ (wisi-set-parse-try nil)
+ (wisi--run-parse begin end)
+
+ ;; If there were errors corrected, the indentation is
+ ;; potentially ambiguous; see
+ ;; test/ada_mode-interactive_2.adb. Or it was a partial parse,
+ ;; where errors producing bad indent are pretty much expected.
+ (unless (wisi-partial-parse-p begin end)
+ (setq wisi-indent-failed (< 0 (+ (length (wisi-parser-lexer-errors
wisi--parser))
+ (length (wisi-parser-parse-errors
wisi--parser))))))
+ )
+
+ (if wisi-parse-failed
+ (progn
+ ;; primary indent failed
+ (setq wisi-indent-failed t)
+ (when (functionp wisi-indent-region-fallback)
+ (when (< 0 wisi-debug)
+ (message "wisi-indent-region fallback"))
+ (funcall wisi-indent-region-fallback begin end)))
+
+ (save-excursion
+ ;; Apply cached indents. Start from end, so indenting
+ ;; doesn't affect correcting for errors in
+ ;; wisi--get-cached-indent.
+ (goto-char (1- end)) ;; end is exclusive
+ (goto-char (line-beginning-position))
+ (let ((wisi-indenting-p t))
+ (while (and (not (bobp))
+ (or (and (= begin end) (= (point) end))
+ (>= (point) begin)))
+ (when (or indent-blank-lines (not (eolp)))
+ ;; ’indent-region’ doesn’t indent an empty line; ’indent-line’
does
+ (let ((indent (if (bobp) 0 (wisi--get-cached-indent begin
end))))
+ (indent-line-to indent))
+ )
+ (forward-line -1))
+
+ ;; Run wisi-indent-calculate-functions
+ (when wisi-indent-calculate-functions
+ (goto-char begin)
+ (while (and (not (eobp))
+ (< (point) end-mark))
+ (back-to-indentation)
+ (let ((indent
+ (run-hook-with-args-until-success
'wisi-indent-calculate-functions)))
+ (when indent
+ (indent-line-to indent)))
+
+ (forward-line 1)))
+ )
+
+ (when
+ (and prev-indent-failed
+ (not wisi-indent-failed))
+ ;; Previous parse failed or indent was potentially
+ ;; ambiguous, this one is not.
+ (goto-char end-mark)
+ (when (< 0 wisi-debug)
+ (message "wisi-indent-region post-parse-fail-hook"))
+ (run-hooks 'wisi-post-indent-fail-hook))
+ ))
+ )))
(defun wisi-indent-line ()
"For `indent-line-function'."
@@ -1271,7 +1370,7 @@ If INDENT-BLANK-LINES is non-nil, also indent blank lines
(for use as
(when (>= (point) savep)
(setq to-indent t))
- (wisi-indent-region (line-beginning-position (-
wisi-indent-context-lines)) (1+ (line-end-position)) t)
+ (wisi-indent-region (line-beginning-position (1+ (-
wisi-indent-context-lines))) (1+ (line-end-position)) t)
(goto-char savep)
(when to-indent (back-to-indentation))
@@ -1286,12 +1385,18 @@ If INDENT-BLANK-LINES is non-nil, also indent blank
lines (for use as
(insert (wisi--lexer-error-inserted data)))
((wisi--parse-error-p data)
(dolist (repair (wisi--parse-error-repair data))
+ (goto-char (wisi--parse-error-repair-pos repair))
(when (< 0 (length (wisi--parse-error-repair-deleted repair)))
(delete-region (car (wisi--parse-error-repair-deleted-region repair))
- (cdr (wisi--parse-error-repair-deleted-region
repair))))
+ (cdr (wisi--parse-error-repair-deleted-region repair)))
+ (when (= ? (char-after (point)))
+ (delete-char 1)))
(dolist (id (wisi--parse-error-repair-inserted repair))
- (insert (cdr (assoc id (wisi-parser-repair-image wisi--parser))))
- (insert " "))
+ (when (and (not (bobp))
+ (not (= ?\( (char-before (point))))
+ (member (syntax-class (syntax-after (1- (point)))) '(2
3))) ;; word or symbol
+ (insert " "))
+ (insert (cdr (assoc id (wisi-parser-repair-image wisi--parser)))))
))
)))
@@ -1302,7 +1407,6 @@ If INDENT-BLANK-LINES is non-nil, also indent blank lines
(for use as
(if (= 1 (+ (length (wisi-parser-lexer-errors wisi--parser))
(length (wisi-parser-parse-errors wisi--parser))))
(progn
- (wisi-goto-error)
(wisi-repair-error-1 (or (car (wisi-parser-lexer-errors wisi--parser))
(car (wisi-parser-parse-errors
wisi--parser)))))
(if (buffer-live-p wisi-error-buffer)
@@ -1339,14 +1443,16 @@ If non-nil, only repair errors in BEG END region."
"Match line number encoded into identifier by
`wisi-xref-identifier-at-point'.")
(defun wisi-xref-ident-make (identifier &optional other-function)
+ "Return an xref-item for IDENTIFIER."
(let* ((t-prop (get-text-property 0 'xref-identifier identifier))
;; If t-prop is non-nil: identifier is from
;; identifier-at-point, the desired location is the ’other’
;; (spec/body).
;;
;; If t-prop is nil: identifier is from prompt/completion,
- ;; the line number may be included in the identifier
- ;; wrapped in <>, and the desired file is the current file.
+ ;; the line number may be included in the identifier wrapped
+ ;; in <>, and the desired location is that line in the current
+ ;; file.
(ident
(if t-prop
(substring-no-properties identifier 0 nil)
@@ -1371,9 +1477,47 @@ If non-nil, only repair errors in BEG END region."
(if t-prop
(funcall other-function ident file line column)
- (list (xref-make ident (xref-make-file-location file (or line 1)
column)))
+ (xref-make ident (xref-make-file-location file (or line 1) column))
)))
+(defun wisi-xref-item (identifier)
+ "Given IDENTIFIER, return an xref-item, with line, column nil if unknown.
+IDENTIFIER is from a user prompt with completion, or from
+`xref-backend-identifier-at-point'."
+ (let* ((t-prop (get-text-property 0 'xref-identifier identifier))
+ ;; If t-prop is non-nil: identifier is from
+ ;; identifier-at-point.
+ ;;
+ ;; If t-prop is nil: identifier is from prompt/completion,
+ ;; the line number may be included in the identifier
+ ;; wrapped in <>.
+ (ident
+ (if t-prop
+ (substring-no-properties identifier 0 nil)
+ (string-match wisi-xref-ident-regexp identifier)
+ (match-string 1 identifier)
+ ))
+ (file
+ (if t-prop
+ (plist-get t-prop ':file)
+ (buffer-file-name)))
+ (line
+ (if t-prop
+ (plist-get t-prop ':line)
+ (when (match-string 2 identifier)
+ (string-to-number (match-string 2 identifier)))))
+ (column
+ (when t-prop
+ (plist-get t-prop ':column)))
+ )
+
+ (unless (file-name-absolute-p file)
+ (setq file (locate-file file compilation-search-path)))
+
+ (let ((eieio-skip-typecheck t)) ;; allow line, column nil.
+ (xref-make ident (xref-make-file-location file line column)))
+ ))
+
(defun wisi-xref-identifier-at-point ()
(let ((ident (thing-at-point 'symbol)))
(when ident
@@ -1414,45 +1558,57 @@ If non-nil, only repair errors in BEG END region."
(let ((region (wisi-prev-name-region)))
(buffer-substring-no-properties (car region) (cdr region))))
-(defun wisi-xref-identifier-completion-table ()
- (wisi-validate-cache (point-min) (point-max) t 'navigate)
- (let ((table nil)
- (pos (point-min))
- end-pos)
- (while (setq pos (next-single-property-change pos 'wisi-name))
- ;; We can’t store location data in a string text property -
- ;; it does not survive completion. So we include the line
- ;; number in the identifier string. This also serves to
- ;; disambiguate overloaded identifiers.
- (setq end-pos (next-single-property-change pos 'wisi-name))
- (push
- (format "%s<%d>"
- (buffer-substring-no-properties pos end-pos)
- (line-number-at-pos pos))
- table)
- (setq pos end-pos)
- )
- table))
+(defun wisi-names (append-lines)
+ "List of names; each is text from one 'wisi-name property in current buffer.
+If APPEND-LINES is non-nil, each has the line number it occurs on appended."
+ (when wisi--parser
+ ;; wisi--parser is nil in a non-language buffer, like Makefile
+ (wisi-validate-cache (point-min) (point-max) t 'navigate)
+ (let ((table nil)
+ (pos (point-min))
+ end-pos)
+ (while (setq pos (next-single-property-change pos 'wisi-name))
+ ;; We can’t store location data in a string text property -
+ ;; it does not survive completion. So we include the line
+ ;; number in the identifier string. This also serves to
+ ;; disambiguate overloaded identifiers in the user interface.
+ (setq end-pos (next-single-property-change pos 'wisi-name))
+ (push
+ (if append-lines
+ (format "%s<%d>"
+ (buffer-substring-no-properties pos end-pos)
+ (line-number-at-pos pos))
+ (buffer-substring-no-properties pos end-pos))
+ table)
+ (setq pos end-pos)
+ )
+ table)))
;;;; debugging
-(defun wisi-show-region (string)
- (interactive "Mregion: ")
- (when (not (= ?\( (aref string 0)))
- (setq string (concat "(" string ")")))
+(defun wisi-show-region ()
+ (interactive)
+ (cond
+ ((use-region-p)
+ (message "(%s . %s)" (region-beginning) (region-end)))
+ (t
+ (let ((string (read-from-minibuffer "region: ")))
+ (when (not (= ?\( (aref string 0)))
+ (setq string (concat "(" string ")")))
- (let ((region (read string)))
- (cond
- ((consp (cdr region))
- ;; region is a list; (begin end)
- (set-mark (nth 0 region))
- (goto-char (nth 1 region)))
-
- ((consp region)
- ;; region is a cons; (begin . end)
- (set-mark (car region))
- (goto-char (cdr region)))
- )))
+ (let ((region (read string)))
+ (cond
+ ((consp (cdr region))
+ ;; region is a list; (begin end)
+ (set-mark (nth 0 region))
+ (goto-char (nth 1 region)))
+
+ ((consp region)
+ ;; region is a cons; (begin . end)
+ (set-mark (car region))
+ (goto-char (cdr region)))
+ ))))
+ ))
(defun wisi-debug-keys ()
"Add debug key definitions to `global-map'."
@@ -1486,7 +1642,7 @@ If non-nil, only repair errors in BEG END region."
'font-lock-face nil
'fontified nil)))
(wisi-validate-cache begin end t parse-action)
- (when (fboundp 'font-lock-ensure) (font-lock-ensure))) ;; emacs < 25
+ (font-lock-ensure))
(navigate
(wisi-validate-cache begin end t parse-action))
@@ -1602,7 +1758,7 @@ If non-nil, only repair errors in BEG END region."
(cons 'navigate nil)
(cons 'indent nil)))
- ;; file local variables may have added opentoken, gnatprep
+ ;; file local variables may have modified wisi-indent-calculate-functions
(setq wisi-indent-calculate-functions (append
wisi-indent-calculate-functions indent-calculate))
(set (make-local-variable 'indent-line-function) #'wisi-indent-line)
(set (make-local-variable 'indent-region-function) #'wisi-indent-region)
@@ -1615,18 +1771,14 @@ If non-nil, only repair errors in BEG END region."
(add-hook 'after-change-functions #'wisi-after-change nil t)
(setq wisi--change-end (copy-marker (point-min) t))
- ;; See comments above on syntax-propertize.
- (when (< emacs-major-version 25) (syntax-propertize (point-max)))
+ (set (make-local-variable 'comment-indent-function) 'wisi-comment-indent)
- ;; In Emacs >= 26, ‘run-mode-hooks’ (in the major mode function)
- ;; runs ‘hack-local-variables’ after ’*-mode-hooks’; we need
- ;; ‘wisi-post-local-vars’ to run after ‘hack-local-variables’.
(add-hook 'hack-local-variables-hook 'wisi-post-local-vars nil t)
)
(defun wisi-post-local-vars ()
"See wisi-setup."
- (setq hack-local-variables-hook (delq 'wisi-post-local-vars
hack-local-variables-hook))
+ (remove-hook 'hack-local-variables-hook #'wisi-post-local-vars)
(unless wisi-disable-face
(jit-lock-register #'wisi-fontify-region)))
diff --git a/packages/wisi/wisi.gpr b/packages/wisi/wisi.gpr.gp
similarity index 93%
rename from packages/wisi/wisi.gpr
rename to packages/wisi/wisi.gpr.gp
index 27e890d..1c17529 100644
--- a/packages/wisi/wisi.gpr
+++ b/packages/wisi/wisi.gpr.gp
@@ -1,6 +1,7 @@
-- Abstract :
--
--- Make installed ELPA package wisi Ada code available for other projects.
+-- Make installed and source ELPA package wisi Ada code available for
+-- other projects.
--
-- Copyright (C) 2017, 2019 Free Software Foundation, Inc.
--
@@ -18,6 +19,10 @@
with "gnatcoll";
with "standard_common";
+#if ELPA="no"
+with "sal";
+with "wisitoken";
+#end if;
project Wisi is
for Source_Dirs use (".");
diff --git a/packages/wisi/wisitoken-bnf-generate.adb
b/packages/wisi/wisitoken-bnf-generate.adb
index 72a0221..a7616b4 100644
--- a/packages/wisi/wisitoken-bnf-generate.adb
+++ b/packages/wisi/wisitoken-bnf-generate.adb
@@ -52,7 +52,7 @@ is
begin
-- verbosity meaning is actually determined by output choice;
-- they should be consistent with this description.
- Put_Line (Standard_Error, "version 1.3.0");
+ Put_Line (Standard_Error, "version 1.3.1");
Put_Line (Standard_Error, "wisitoken-bnf-generate [options] {wisi
grammar file}");
Put_Line (Standard_Error, "Generate source code implementing a parser
for the grammar.");
New_Line (Standard_Error);
diff --git a/packages/wisi/wisitoken-bnf-output_ada_common.adb
b/packages/wisi/wisitoken-bnf-output_ada_common.adb
index 97ec9ed..ed4ef64 100644
--- a/packages/wisi/wisitoken-bnf-output_ada_common.adb
+++ b/packages/wisi/wisitoken-bnf-output_ada_common.adb
@@ -1008,7 +1008,7 @@ package body WisiToken.BNF.Output_Ada_Common is
Indent_Line ("result->buffer_last = input + length - 1;");
Indent_Line ("result->cursor = input;");
Indent_Line ("result->byte_token_start = input;");
- Indent_Line ("result->char_pos = 1;");
+ Indent_Line ("result->char_pos = 1; /* match
WisiToken.Buffer_Region */");
Indent_Line ("result->char_token_start = 1;");
Indent_Line ("result->line = (*result->cursor == 0x0A) ? 2
: 1;");
Indent_Line ("result->line_token_start = result->line;");
@@ -1064,19 +1064,23 @@ package body WisiToken.BNF.Output_Ada_Common is
Indent_Line ("#define YYPEEK() (lexer->cursor <= lexer->buffer_last) ?
*lexer->cursor : 4");
New_Line;
- -- Don't count UTF-8 continuation bytes, or first byte of DOS newline
- Indent_Line ("#define DO_COUNT ((*lexer->cursor & 0xC0) != 0xC0) &&
(*lexer->cursor != 0x0D)");
- New_Line;
-
Indent_Line ("static void skip(wisi_lexer* lexer)");
Indent_Line ("{");
Indent := Indent + 3;
Indent_Line ("if (lexer->cursor <= lexer->buffer_last)");
- Indent_Line ("{");
Indent_Line (" ++lexer->cursor;");
- Indent_Line (" if (DO_COUNT) ++lexer->char_pos;");
- Indent_Line (" if (lexer->cursor <= lexer->buffer_last)");
- Indent_Line (" if (*lexer->cursor == 0x0A) ++lexer->line;");
+ Indent_Line ("if (lexer->cursor <= lexer->buffer_last)");
+ Indent_Line ("{");
+ Indent_Line (" /* UFT-8 encoding:
https://en.wikipedia.org/wiki/UTF-8#Description */");
+ Indent_Line (" if (*lexer->cursor == 0x0A && lexer->cursor >
lexer->buffer && *(lexer->cursor - 1) == 0x0D)");
+ Indent_Line (" {/* second byte of DOS line ending */");
+ Indent_Line (" }");
+ Indent_Line (" else if ((*lexer->cursor & 0x80) == 0x80 &&
(*lexer->cursor & 0xC0) != 0xC0)");
+ Indent_Line (" {/* byte 2, 3 or 4 of multi-byte UTF-8 char */");
+ Indent_Line (" }");
+ Indent_Line (" else");
+ Indent_Line (" ++lexer->char_pos;");
+ Indent_Line (" if (*lexer->cursor == 0x0A) ++lexer->line;");
Indent_Line ("}");
Indent := Indent - 3;
Indent_Line ("}");
@@ -1232,17 +1236,15 @@ package body WisiToken.BNF.Output_Ada_Common is
Indent_Line ("* {status = ERROR_unrecognized_character; continue;}");
Put_Line ("*/");
- Indent_Line ("}");
Indent := Indent - 3;
+ Indent_Line ("}");
+ Indent_Line ("/* lexer->cursor and lexer ->char_pos are one char past
end of token */");
Indent_Line ("*byte_position = lexer->byte_token_start - lexer->buffer +
1;");
Indent_Line ("*byte_length = lexer->cursor -
lexer->byte_token_start;");
Indent_Line ("*char_position = lexer->char_token_start;");
- Indent_Line ("if (DO_COUNT)");
- Indent_Line (" *char_length = lexer->char_pos -
lexer->char_token_start;");
- Indent_Line ("else");
- Indent_Line (" *char_length = lexer->char_pos -
lexer->char_token_start + 1;");
- Indent_Line ("*line_start = lexer->line_token_start;");
+ Indent_Line ("*char_length = lexer->char_pos -
lexer->char_token_start;");
+ Indent_Line ("*line_start = lexer->line_token_start;");
Indent_Line ("return status;");
Indent_Line ("}");
Indent := Indent - 3;
diff --git a/packages/wisi/wisitoken-parse-lr-mckenzie_recover-explore.adb
b/packages/wisi/wisitoken-parse-lr-mckenzie_recover-explore.adb
index f749cfb..b6c9e43 100644
--- a/packages/wisi/wisitoken-parse-lr-mckenzie_recover-explore.adb
+++ b/packages/wisi/wisitoken-parse-lr-mckenzie_recover-explore.adb
@@ -546,7 +546,7 @@ package body WisiToken.Parse.LR.McKenzie_Recover.Explore is
New_Config.Current_Shared_Token := Token.Min_Terminal_Index;
end if;
end if;
- New_Config.Strategy_Counts (Explore_Table) :=
New_Config.Strategy_Counts (Explore_Table) + 1;
+ New_Config.Strategy_Counts (Push_Back) :=
New_Config.Strategy_Counts (Push_Back) + 1;
Local_Config_Heap.Add (New_Config);
@@ -613,7 +613,7 @@ package body WisiToken.Parse.LR.McKenzie_Recover.Explore is
else
Append (New_Config.Ops, (Undo_Reduce, Token.ID, Token_Count));
end if;
- New_Config.Strategy_Counts (Explore_Table) :=
New_Config.Strategy_Counts (Explore_Table) + 1;
+ New_Config.Strategy_Counts (Undo_Reduce) :=
New_Config.Strategy_Counts (Undo_Reduce) + 1;
Local_Config_Heap.Add (New_Config);
@@ -695,7 +695,7 @@ package body WisiToken.Parse.LR.McKenzie_Recover.Explore is
Do_Shift
("Insert", Super, Shared, Parser_Index,
Local_Config_Heap, New_Config, Action.State, ID,
Cost_Delta => 0,
- Strategy => Explore_Table);
+ Strategy => Insert);
end;
when Reduce =>
@@ -714,7 +714,7 @@ package body WisiToken.Parse.LR.McKenzie_Recover.Explore is
Do_Reduce_2
("Insert", Super, Shared, Parser_Index,
Local_Config_Heap, New_Config, ID,
Cost_Delta => 0,
- Strategy => Explore_Table);
+ Strategy => Insert);
end;
else
@@ -724,7 +724,7 @@ package body WisiToken.Parse.LR.McKenzie_Recover.Explore is
Do_Reduce_2
("Insert", Super, Shared, Parser_Index,
Local_Config_Heap, New_Config, ID,
Cost_Delta => 0,
- Strategy => Explore_Table);
+ Strategy => Insert);
end;
end if;
@@ -1520,7 +1520,7 @@ package body WisiToken.Parse.LR.McKenzie_Recover.Explore
is
New_Config.Check_Status := (Label =>
WisiToken.Semantic_Checks.Ok);
New_Config.Cost := New_Config.Cost + McKenzie_Param.Delete (ID);
- New_Config.Strategy_Counts (Explore_Table) :=
Config.Strategy_Counts (Explore_Table) + 1;
+ New_Config.Strategy_Counts (Delete) := Config.Strategy_Counts
(Delete) + 1;
if Matching_Push_Back then
-- We are deleting a push_back; cancel the push_back cost, to
make
diff --git a/packages/wisi/wisitoken-parse-lr-mckenzie_recover.adb
b/packages/wisi/wisitoken-parse-lr-mckenzie_recover.adb
index c53f0ef..6fa41d8 100644
--- a/packages/wisi/wisitoken-parse-lr-mckenzie_recover.adb
+++ b/packages/wisi/wisitoken-parse-lr-mckenzie_recover.adb
@@ -2,7 +2,7 @@
--
-- See spec
--
--- Copyright (C) 2017 - 2019 Free Software Foundation, Inc.
+-- Copyright (C) 2017 - 2020 Free Software Foundation, Inc.
--
-- This library is free software; you can redistribute it and/or modify it
-- under terms of the GNU General Public License as published by the Free
@@ -245,7 +245,7 @@ package body WisiToken.Parse.LR.McKenzie_Recover is
if Trace_McKenzie > Outline then
Trace.New_Line;
- Trace.Put_Line (System.Multiprocessors.CPU_Range'Image
(Worker_Tasks'Last) & " parallel tasks");
+ Trace.Put_Line (Task_Count'Image & " parallel tasks");
end if;
for I in Worker_Tasks'First .. Task_Count loop
@@ -718,8 +718,10 @@ package body WisiToken.Parse.LR.McKenzie_Recover is
when E : others =>
if Debug_Mode then
Trace.Put (Ada.Exceptions.Exception_Name (E) & ": " &
Ada.Exceptions.Exception_Message (E));
+ raise;
+ else
+ return Fail_Programmer_Error;
end if;
- return Fail_Programmer_Error;
end Recover;
----------
@@ -921,12 +923,20 @@ package body WisiToken.Parse.LR.McKenzie_Recover is
Config : in out Configuration;
Index : in out WisiToken.Token_Index;
ID : in Token_ID)
+ is begin
+ Check (Terminals (Index).ID, ID);
+ Delete (Terminals, Config, Index);
+ end Delete_Check;
+
+ procedure Delete
+ (Terminals : in Base_Token_Arrays.Vector;
+ Config : in out Configuration;
+ Index : in out WisiToken.Token_Index)
is
use Config_Op_Arrays;
use Sorted_Insert_Delete_Arrays;
- Op : constant Config_Op := (Delete, ID, Index);
+ Op : constant Config_Op := (Delete, Terminals (Index).ID, Index);
begin
- Check (Terminals (Index).ID, ID);
if Is_Full (Config.Ops) or Is_Full (Config.Insert_Delete) then
raise Bad_Config;
end if;
@@ -934,7 +944,7 @@ package body WisiToken.Parse.LR.McKenzie_Recover is
Insert (Config.Insert_Delete, Op);
Config.Current_Insert_Delete := 1;
Index := Index + 1;
- end Delete_Check;
+ end Delete;
procedure Find_ID
(Config : in Configuration;
@@ -1057,10 +1067,22 @@ package body WisiToken.Parse.LR.McKenzie_Recover is
end Find_Matching_Name;
procedure Insert (Config : in out Configuration; ID : in Token_ID)
+ is begin
+ Insert (Config, Config.Current_Shared_Token, ID);
+ end Insert;
+
+ procedure Insert (Config : in out Configuration; IDs : in Token_ID_Array)
+ is begin
+ for ID of IDs loop
+ Insert (Config, ID);
+ end loop;
+ end Insert;
+
+ procedure Insert (Config : in out Configuration; Index : in
WisiToken.Token_Index; ID : in Token_ID)
is
use Config_Op_Arrays;
use Sorted_Insert_Delete_Arrays;
- Op : constant Config_Op := (Insert, ID, Config.Current_Shared_Token,
Unknown_State, 0);
+ Op : constant Config_Op := (Insert, ID, Index, Unknown_State, 0);
begin
if Is_Full (Config.Ops) or Is_Full (Config.Insert_Delete) then
raise Bad_Config;
@@ -1070,13 +1092,6 @@ package body WisiToken.Parse.LR.McKenzie_Recover is
Config.Current_Insert_Delete := 1;
end Insert;
- procedure Insert (Config : in out Configuration; IDs : in Token_ID_Array)
- is begin
- for ID of IDs loop
- Insert (Config, ID);
- end loop;
- end Insert;
-
function Next_Token
(Terminals : in Base_Token_Arrays.Vector;
Terminals_Current : in out Base_Token_Index;
diff --git a/packages/wisi/wisitoken-parse-lr-mckenzie_recover.ads
b/packages/wisi/wisitoken-parse-lr-mckenzie_recover.ads
index 9b84a03..dedad36 100644
--- a/packages/wisi/wisitoken-parse-lr-mckenzie_recover.ads
+++ b/packages/wisi/wisitoken-parse-lr-mckenzie_recover.ads
@@ -118,6 +118,12 @@ private
-- order. Increments Index, for convenience when deleting several
-- tokens.
+ procedure Delete
+ (Terminals : in Base_Token_Arrays.Vector;
+ Config : in out Configuration;
+ Index : in out WisiToken.Token_Index);
+ -- Same as Delete_Check, without the check.
+
procedure Find_ID
(Config : in Configuration;
ID : in Token_ID;
@@ -170,16 +176,19 @@ private
-- Also count tokens with ID = Other_ID.
procedure Insert (Config : in out Configuration; ID : in Token_ID);
- -- Append an Insert op to Config.Ops, and insert it in
- -- Config.Insert_Deleted in token_index order.
+ -- Append an Insert op at Config.Current_Shared_Token, to Config.Ops,
+ -- and insert it in Config.Insert_Deleted in token_index order.
procedure Insert (Config : in out Configuration; IDs : in Token_ID_Array);
-- Call Insert for each item in IDs.
+ procedure Insert (Config : in out Configuration; Index : in
WisiToken.Token_Index; ID : in Token_ID);
+ -- Same as Insert, but at Index, not Config.Current_Shared_Token.
+
function Next_Token
(Terminals : in Base_Token_Arrays.Vector;
Terminals_Current : in out Base_Token_Index;
- Restore_Terminals_Current : in out WisiToken.Base_Token_Index;
+ Restore_Terminals_Current : in out Base_Token_Index;
Insert_Delete : aliased in out
Sorted_Insert_Delete_Arrays.Vector;
Current_Insert_Delete : in out SAL.Base_Peek_Type;
Prev_Deleted : in
Recover_Token_Index_Arrays.Vector)
diff --git a/packages/wisi/wisitoken-parse-lr-parser.adb
b/packages/wisi/wisitoken-parse-lr-parser.adb
index 70fab20..44c1ac0 100644
--- a/packages/wisi/wisitoken-parse-lr-parser.adb
+++ b/packages/wisi/wisitoken-parse-lr-parser.adb
@@ -368,13 +368,16 @@ package body WisiToken.Parse.LR.Parser is
is
use all type Syntax_Trees.User_Data_Access;
begin
- Parser.Lexer := Lexer;
- Parser.Trace := Trace;
+ Parser.Lexer := Lexer;
+ Parser.Trace := Trace;
+ Parser.User_Data := User_Data;
+
+ -- Terminals, Line_Begin_Token are initialized to empty arrays.
+
Parser.Table := Table;
Parser.Language_Fixes := Language_Fixes;
Parser.Language_Matching_Begin_Tokens := Language_Matching_Begin_Tokens;
Parser.Language_String_ID_Set := Language_String_ID_Set;
- Parser.User_Data := User_Data;
Parser.Enable_McKenzie_Recover := not McKenzie_Defaulted (Table.all);
@@ -701,18 +704,18 @@ package body WisiToken.Parse.LR.Parser is
if Ada.Text_IO.Is_Open (Shared_Parser.Recover_Log_File) then
declare
use Ada.Text_IO;
- Strategy_Counts : LR.Strategy_Counts := (others => 0);
begin
Put
(Shared_Parser.Recover_Log_File,
Ada.Calendar.Formatting.Image (Ada.Calendar.Clock)
& " " &
- McKenzie_Recover.Recover_Status'Image
(Recover_Result) & " " &
- SAL.Base_Peek_Type'Image
(Pre_Recover_Parser_Count) & " '" &
+ Shared_Parser.Partial_Parse_Active'Image & " " &
+ Recover_Result'Image & " " &
+ Pre_Recover_Parser_Count'Image & " '" &
Shared_Parser.Lexer.File_Name & "'");
Put (Shared_Parser.Recover_Log_File, '(');
for Parser of Shared_Parser.Parsers loop
- Accumulate (Parser.Recover, Strategy_Counts);
+ Put (Shared_Parser.Recover_Log_File, Image
(Parser.Recover.Results.Peek.Strategy_Counts));
Put
(Shared_Parser.Recover_Log_File,
Integer'Image (Parser.Recover.Enqueue_Count) &
@@ -721,7 +724,6 @@ package body WisiToken.Parse.LR.Parser is
end loop;
Put (Shared_Parser.Recover_Log_File, ')');
- Put (Shared_Parser.Recover_Log_File, Image
(Strategy_Counts));
New_Line (Shared_Parser.Recover_Log_File);
Flush (Shared_Parser.Recover_Log_File);
end;
@@ -1064,6 +1066,9 @@ package body WisiToken.Parse.LR.Parser is
Parser_State : Parser_Lists.Parser_State renames
Parser.Parsers.First_State_Ref;
begin
if Trace_Action > Outline then
+ if Trace_Action > Extra then
+ Parser_State.Tree.Print_Tree (Descriptor,
Parser_State.Tree.Root);
+ end if;
Parser.Trace.Put_Line
(Integer'Image (Parser_State.Label) & ": root node: " &
Parser_State.Tree.Image
(Parser_State.Tree.Root, Descriptor));
diff --git a/packages/wisi/wisitoken-parse-lr-parser.ads
b/packages/wisi/wisitoken-parse-lr-parser.ads
index e84d65d..18f476e 100644
--- a/packages/wisi/wisitoken-parse-lr-parser.ads
+++ b/packages/wisi/wisitoken-parse-lr-parser.ads
@@ -109,6 +109,8 @@ package WisiToken.Parse.LR.Parser is
Terminate_Same_State : Boolean;
Enable_McKenzie_Recover : Boolean;
Recover_Log_File : Ada.Text_IO.File_Type;
+ Partial_Parse_Active : Boolean := False;
+ -- Partial_Parse_Active is only used in recover log messages.
end record;
overriding procedure Finalize (Object : in out LR.Parser.Parser);
diff --git a/packages/wisi/wisitoken-parse-lr.ads
b/packages/wisi/wisitoken-parse-lr.ads
index 76a02d5..36f8889 100644
--- a/packages/wisi/wisitoken-parse-lr.ads
+++ b/packages/wisi/wisitoken-parse-lr.ads
@@ -546,7 +546,8 @@ package WisiToken.Parse.LR is
-- which is true if they were copied from the parser stack, and not
-- pushed by recover.
- type Strategies is (Language_Fix, Minimal_Complete, Matching_Begin,
Explore_Table, String_Quote);
+ type Strategies is
+ (Language_Fix, Minimal_Complete, Matching_Begin, Push_Back, Undo_Reduce,
Insert, Delete, String_Quote);
type Strategy_Counts is array (Strategies) of Natural;
function Image is new SAL.Gen_Array_Image (Strategies, Natural,
Strategy_Counts, Trimmed_Image);
diff --git a/packages/wisi/wisitoken-parse.adb
b/packages/wisi/wisitoken-parse.adb
index ee7b1e8..3685b4e 100644
--- a/packages/wisi/wisitoken-parse.adb
+++ b/packages/wisi/wisitoken-parse.adb
@@ -21,6 +21,7 @@ package body WisiToken.Parse is
function Next_Grammar_Token (Parser : in out Base_Parser) return Token_ID
is
+ use all type Ada.Containers.Count_Type;
use all type Syntax_Trees.User_Data_Access;
Token : Base_Token;
@@ -38,12 +39,16 @@ package body WisiToken.Parse is
if Token.Line /= Invalid_Line_Number then
-- Some lexers don't support line numbers.
if Parser.Lexer.First then
- Parser.Line_Begin_Token.Set_First_Last (Line_Number_Type'First,
Token.Line);
+ if Parser.Line_Begin_Token.Length = 0 then
+ Parser.Line_Begin_Token.Set_First_Last (Token.Line,
Token.Line);
+ else
+ Parser.Line_Begin_Token.Set_First_Last
(Parser.Line_Begin_Token.First_Index, Token.Line);
+ end if;
Parser.Line_Begin_Token (Token.Line) :=
Parser.Terminals.Last_Index +
(if Token.ID >= Parser.Trace.Descriptor.First_Terminal then 1
else 0);
elsif Token.ID = Parser.Trace.Descriptor.EOI_ID then
- Parser.Line_Begin_Token.Set_First_Last (Line_Number_Type'First,
Token.Line + 1);
+ Parser.Line_Begin_Token.Set_First_Last
(Parser.Line_Begin_Token.First_Index, Token.Line + 1);
Parser.Line_Begin_Token (Token.Line + 1) :=
Parser.Terminals.Last_Index + 1;
end if;
end if;
diff --git a/packages/wisi/wisitoken-parse.ads
b/packages/wisi/wisitoken-parse.ads
index c2fb500..edecb90 100644
--- a/packages/wisi/wisitoken-parse.ads
+++ b/packages/wisi/wisitoken-parse.ads
@@ -23,11 +23,20 @@ with WisiToken.Syntax_Trees;
package WisiToken.Parse is
type Base_Parser is abstract new Ada.Finalization.Limited_Controlled with
record
- Trace : access WisiToken.Trace'Class;
- Lexer : WisiToken.Lexer.Handle;
- User_Data : WisiToken.Syntax_Trees.User_Data_Access;
- Terminals : aliased WisiToken.Base_Token_Arrays.Vector;
+ Trace : access WisiToken.Trace'Class;
+ Lexer : WisiToken.Lexer.Handle;
+ User_Data : WisiToken.Syntax_Trees.User_Data_Access;
+ Terminals : aliased WisiToken.Base_Token_Arrays.Vector;
+
Line_Begin_Token : aliased WisiToken.Line_Begin_Token_Vectors.Vector;
+ -- Line_Begin_Token (I) is the index into Terminals of the first
+ -- grammar token on line I. Line_Begin_Token.First_Index is the first
+ -- line containing a grammar token (after leading comments). However,
+ -- if the only token on line I is a non_grammar token (ie a comment,
+ -- or a newline for a blank line), Line_Begin_Token (I) is the last
+ -- grammar token on the previous non-blank line. If Line (I) is a
+ -- non-first line in a multi-line token, Line_Begin_Token (I) is
+ -- Invalid_Token_Index.
end record;
-- Common to all parsers. Finalize should free any allocated objects.
diff --git a/packages/wisi/wisitoken-semantic_checks.ads
b/packages/wisi/wisitoken-semantic_checks.ads
index 09517e1..c55371e 100644
--- a/packages/wisi/wisitoken-semantic_checks.ads
+++ b/packages/wisi/wisitoken-semantic_checks.ads
@@ -100,6 +100,7 @@ package WisiToken.Semantic_Checks is
Nonterm : in Recover_Token)
return Check_Status;
pragma Inline (Terminate_Partial_Parse);
- -- If Active, raise Wisitoken.Partial_Parse; otherwise return Ok.
+ -- If partial parse is complete, raise Wisitoken.Partial_Parse;
+ -- otherwise return Ok.
end WisiToken.Semantic_Checks;
diff --git a/packages/wisi/wisitoken_grammar_re2c.c
b/packages/wisi/wisitoken_grammar_re2c.c
index f4185ee..ef82744 100644
--- a/packages/wisi/wisitoken_grammar_re2c.c
+++ b/packages/wisi/wisitoken_grammar_re2c.c
@@ -59,7 +59,7 @@ wisi_lexer* wisitoken_grammar_new_lexer
result->buffer_last = input + length - 1;
result->cursor = input;
result->byte_token_start = input;
- result->char_pos = 1;
+ result->char_pos = 1; /* match WisiToken.Buffer_Region */
result->char_token_start = 1;
result->line = (*result->cursor == 0x0A) ? 2 : 1;
result->line_token_start = result->line;
@@ -97,16 +97,22 @@ static void debug(wisi_lexer* lexer, int state, unsigned
char ch)
#define YYPEEK() (lexer->cursor <= lexer->buffer_last) ? *lexer->cursor : 4
-#define DO_COUNT ((*lexer->cursor & 0xC0) != 0xC0) && (*lexer->cursor != 0x0D)
-
static void skip(wisi_lexer* lexer)
{
if (lexer->cursor <= lexer->buffer_last)
- {
++lexer->cursor;
- if (DO_COUNT) ++lexer->char_pos;
- if (lexer->cursor <= lexer->buffer_last)
- if (*lexer->cursor == 0x0A) ++lexer->line;
+ if (lexer->cursor <= lexer->buffer_last)
+ {
+ /* UFT-8 encoding: https://en.wikipedia.org/wiki/UTF-8#Description */
+ if (*lexer->cursor == 0x0A && lexer->cursor > lexer->buffer &&
*(lexer->cursor - 1) == 0x0D)
+ {/* second byte of DOS line ending */
+ }
+ else if ((*lexer->cursor & 0x80) == 0x80 && (*lexer->cursor & 0xC0) !=
0xC0)
+ {/* byte 2, 3 or 4 of multi-byte UTF-8 char */
+ }
+ else
+ ++lexer->char_pos;
+ if (*lexer->cursor == 0x0A) ++lexer->line;
}
}
#define YYSKIP() skip(lexer)
@@ -173,7 +179,7 @@ int wisitoken_grammar_next_token
while (*id == -1 && status == 0)
{
-#line 177 "../wisitoken_grammar_re2c.c"
+#line 183 "../wisitoken_grammar_re2c.c"
{
YYCTYPE yych;
unsigned int yyaccept = 0;
@@ -326,21 +332,21 @@ yy2:
YYSKIP ();
yy3:
YYDEBUG(3, YYPEEK ());
-#line 255 "../wisitoken_grammar.re2c"
+#line 261 "../wisitoken_grammar.re2c"
{status = ERROR_unrecognized_character; continue;}
-#line 332 "../wisitoken_grammar_re2c.c"
+#line 338 "../wisitoken_grammar_re2c.c"
yy4:
YYDEBUG(4, YYPEEK ());
YYSKIP ();
YYDEBUG(5, YYPEEK ());
-#line 253 "../wisitoken_grammar.re2c"
+#line 259 "../wisitoken_grammar.re2c"
{*id = 36; continue;}
-#line 339 "../wisitoken_grammar_re2c.c"
+#line 345 "../wisitoken_grammar_re2c.c"
yy6:
YYDEBUG(6, YYPEEK ());
YYSKIP ();
YYDEBUG(7, YYPEEK ());
-#line 211 "../wisitoken_grammar.re2c"
+#line 217 "../wisitoken_grammar.re2c"
{ lexer->byte_token_start = lexer->cursor;
lexer->char_token_start = lexer->char_pos;
if (*lexer->cursor == 0x0A)
@@ -348,14 +354,14 @@ yy6:
else
lexer->line_token_start = lexer->line;
continue; }
-#line 352 "../wisitoken_grammar_re2c.c"
+#line 358 "../wisitoken_grammar_re2c.c"
yy8:
YYDEBUG(8, YYPEEK ());
YYSKIP ();
YYDEBUG(9, YYPEEK ());
-#line 218 "../wisitoken_grammar.re2c"
+#line 224 "../wisitoken_grammar.re2c"
{*id = 1; continue;}
-#line 359 "../wisitoken_grammar_re2c.c"
+#line 365 "../wisitoken_grammar_re2c.c"
yy10:
YYDEBUG(10, YYPEEK ());
YYSKIP ();
@@ -532,9 +538,9 @@ yy12:
}
yy13:
YYDEBUG(13, YYPEEK ());
-#line 240 "../wisitoken_grammar.re2c"
+#line 246 "../wisitoken_grammar.re2c"
{*id = 23; continue;}
-#line 538 "../wisitoken_grammar_re2c.c"
+#line 544 "../wisitoken_grammar_re2c.c"
yy14:
YYDEBUG(14, YYPEEK ());
yyaccept = 0;
@@ -695,37 +701,37 @@ yy15:
YYDEBUG(15, YYPEEK ());
YYSKIP ();
YYDEBUG(16, YYPEEK ());
-#line 237 "../wisitoken_grammar.re2c"
+#line 243 "../wisitoken_grammar.re2c"
{*id = 20; continue;}
-#line 701 "../wisitoken_grammar_re2c.c"
+#line 707 "../wisitoken_grammar_re2c.c"
yy17:
YYDEBUG(17, YYPEEK ());
YYSKIP ();
YYDEBUG(18, YYPEEK ());
-#line 245 "../wisitoken_grammar.re2c"
+#line 251 "../wisitoken_grammar.re2c"
{*id = 28; continue;}
-#line 708 "../wisitoken_grammar_re2c.c"
+#line 714 "../wisitoken_grammar_re2c.c"
yy19:
YYDEBUG(19, YYPEEK ());
YYSKIP ();
YYDEBUG(20, YYPEEK ());
-#line 248 "../wisitoken_grammar.re2c"
+#line 254 "../wisitoken_grammar.re2c"
{*id = 31; continue;}
-#line 715 "../wisitoken_grammar_re2c.c"
+#line 721 "../wisitoken_grammar_re2c.c"
yy21:
YYDEBUG(21, YYPEEK ());
YYSKIP ();
YYDEBUG(22, YYPEEK ());
-#line 241 "../wisitoken_grammar.re2c"
+#line 247 "../wisitoken_grammar.re2c"
{*id = 24; continue;}
-#line 722 "../wisitoken_grammar_re2c.c"
+#line 728 "../wisitoken_grammar_re2c.c"
yy23:
YYDEBUG(23, YYPEEK ());
YYSKIP ();
YYDEBUG(24, YYPEEK ());
-#line 232 "../wisitoken_grammar.re2c"
+#line 238 "../wisitoken_grammar.re2c"
{*id = 15; continue;}
-#line 729 "../wisitoken_grammar_re2c.c"
+#line 735 "../wisitoken_grammar_re2c.c"
yy25:
YYDEBUG(25, YYPEEK ());
YYSKIP ();
@@ -746,16 +752,16 @@ yy25:
}
yy26:
YYDEBUG(26, YYPEEK ());
-#line 239 "../wisitoken_grammar.re2c"
+#line 245 "../wisitoken_grammar.re2c"
{*id = 22; continue;}
-#line 752 "../wisitoken_grammar_re2c.c"
+#line 758 "../wisitoken_grammar_re2c.c"
yy27:
YYDEBUG(27, YYPEEK ());
YYSKIP ();
YYDEBUG(28, YYPEEK ());
-#line 247 "../wisitoken_grammar.re2c"
+#line 253 "../wisitoken_grammar.re2c"
{*id = 30; continue;}
-#line 759 "../wisitoken_grammar_re2c.c"
+#line 765 "../wisitoken_grammar_re2c.c"
yy29:
YYDEBUG(29, YYPEEK ());
YYSKIP ();
@@ -777,9 +783,9 @@ yy29:
}
yy31:
YYDEBUG(31, YYPEEK ());
-#line 249 "../wisitoken_grammar.re2c"
+#line 255 "../wisitoken_grammar.re2c"
{*id = 32; continue;}
-#line 783 "../wisitoken_grammar_re2c.c"
+#line 789 "../wisitoken_grammar_re2c.c"
yy32:
YYDEBUG(32, YYPEEK ());
yyaccept = 1;
@@ -792,9 +798,9 @@ yy32:
}
yy33:
YYDEBUG(33, YYPEEK ());
-#line 230 "../wisitoken_grammar.re2c"
+#line 236 "../wisitoken_grammar.re2c"
{*id = 13; continue;}
-#line 798 "../wisitoken_grammar_re2c.c"
+#line 804 "../wisitoken_grammar_re2c.c"
yy34:
YYDEBUG(34, YYPEEK ());
YYSKIP ();
@@ -805,37 +811,37 @@ yy34:
}
yy35:
YYDEBUG(35, YYPEEK ());
-#line 246 "../wisitoken_grammar.re2c"
+#line 252 "../wisitoken_grammar.re2c"
{*id = 29; continue;}
-#line 811 "../wisitoken_grammar_re2c.c"
+#line 817 "../wisitoken_grammar_re2c.c"
yy36:
YYDEBUG(36, YYPEEK ());
YYSKIP ();
YYDEBUG(37, YYPEEK ());
-#line 238 "../wisitoken_grammar.re2c"
+#line 244 "../wisitoken_grammar.re2c"
{*id = 21; continue;}
-#line 818 "../wisitoken_grammar_re2c.c"
+#line 824 "../wisitoken_grammar_re2c.c"
yy38:
YYDEBUG(38, YYPEEK ());
YYSKIP ();
YYDEBUG(39, YYPEEK ());
-#line 233 "../wisitoken_grammar.re2c"
+#line 239 "../wisitoken_grammar.re2c"
{*id = 16; continue;}
-#line 825 "../wisitoken_grammar_re2c.c"
+#line 831 "../wisitoken_grammar_re2c.c"
yy40:
YYDEBUG(40, YYPEEK ());
YYSKIP ();
YYDEBUG(41, YYPEEK ());
-#line 234 "../wisitoken_grammar.re2c"
+#line 240 "../wisitoken_grammar.re2c"
{*id = 17; continue;}
-#line 832 "../wisitoken_grammar_re2c.c"
+#line 838 "../wisitoken_grammar_re2c.c"
yy42:
YYDEBUG(42, YYPEEK ());
YYSKIP ();
YYDEBUG(43, YYPEEK ());
-#line 242 "../wisitoken_grammar.re2c"
+#line 248 "../wisitoken_grammar.re2c"
{*id = 25; continue;}
-#line 839 "../wisitoken_grammar_re2c.c"
+#line 845 "../wisitoken_grammar_re2c.c"
yy44:
YYDEBUG(44, YYPEEK ());
yyaccept = 2;
@@ -964,23 +970,23 @@ yy45:
}
yy46:
YYDEBUG(46, YYPEEK ());
-#line 250 "../wisitoken_grammar.re2c"
+#line 256 "../wisitoken_grammar.re2c"
{*id = 33; continue;}
-#line 970 "../wisitoken_grammar_re2c.c"
+#line 976 "../wisitoken_grammar_re2c.c"
yy47:
YYDEBUG(47, YYPEEK ());
YYSKIP ();
YYDEBUG(48, YYPEEK ());
-#line 236 "../wisitoken_grammar.re2c"
+#line 242 "../wisitoken_grammar.re2c"
{*id = 19; continue;}
-#line 977 "../wisitoken_grammar_re2c.c"
+#line 983 "../wisitoken_grammar_re2c.c"
yy49:
YYDEBUG(49, YYPEEK ());
YYSKIP ();
YYDEBUG(50, YYPEEK ());
-#line 244 "../wisitoken_grammar.re2c"
+#line 250 "../wisitoken_grammar.re2c"
{*id = 27; continue;}
-#line 984 "../wisitoken_grammar_re2c.c"
+#line 990 "../wisitoken_grammar_re2c.c"
yy51:
YYDEBUG(51, YYPEEK ());
yyaccept = 2;
@@ -1045,23 +1051,23 @@ yy57:
YYDEBUG(57, YYPEEK ());
YYSKIP ();
YYDEBUG(58, YYPEEK ());
-#line 235 "../wisitoken_grammar.re2c"
+#line 241 "../wisitoken_grammar.re2c"
{*id = 18; continue;}
-#line 1051 "../wisitoken_grammar_re2c.c"
+#line 1057 "../wisitoken_grammar_re2c.c"
yy59:
YYDEBUG(59, YYPEEK ());
YYSKIP ();
YYDEBUG(60, YYPEEK ());
-#line 229 "../wisitoken_grammar.re2c"
+#line 235 "../wisitoken_grammar.re2c"
{*id = 12; continue;}
-#line 1058 "../wisitoken_grammar_re2c.c"
+#line 1064 "../wisitoken_grammar_re2c.c"
yy61:
YYDEBUG(61, YYPEEK ());
YYSKIP ();
YYDEBUG(62, YYPEEK ());
-#line 243 "../wisitoken_grammar.re2c"
+#line 249 "../wisitoken_grammar.re2c"
{*id = 26; continue;}
-#line 1065 "../wisitoken_grammar_re2c.c"
+#line 1071 "../wisitoken_grammar_re2c.c"
yy63:
YYDEBUG(63, YYPEEK ());
YYSKIP ();
@@ -1587,9 +1593,9 @@ yy72:
}
yy73:
YYDEBUG(73, YYPEEK ());
-#line 251 "../wisitoken_grammar.re2c"
+#line 257 "../wisitoken_grammar.re2c"
{*id = 34; continue;}
-#line 1593 "../wisitoken_grammar_re2c.c"
+#line 1599 "../wisitoken_grammar_re2c.c"
yy74:
YYDEBUG(74, YYPEEK ());
YYSKIP ();
@@ -1924,23 +1930,23 @@ yy80:
YYDEBUG(80, YYPEEK ());
YYSKIP ();
YYDEBUG(81, YYPEEK ());
-#line 228 "../wisitoken_grammar.re2c"
+#line 234 "../wisitoken_grammar.re2c"
{*id = 11; skip_to(lexer, ")%"); continue;}
-#line 1930 "../wisitoken_grammar_re2c.c"
+#line 1936 "../wisitoken_grammar_re2c.c"
yy82:
YYDEBUG(82, YYPEEK ());
YYSKIP ();
YYDEBUG(83, YYPEEK ());
-#line 227 "../wisitoken_grammar.re2c"
+#line 233 "../wisitoken_grammar.re2c"
{*id = 10; skip_to(lexer, "]%"); continue;}
-#line 1937 "../wisitoken_grammar_re2c.c"
+#line 1943 "../wisitoken_grammar_re2c.c"
yy84:
YYDEBUG(84, YYPEEK ());
YYSKIP ();
YYDEBUG(85, YYPEEK ());
-#line 226 "../wisitoken_grammar.re2c"
+#line 232 "../wisitoken_grammar.re2c"
{*id = 9; skip_to(lexer, "}%"); continue;}
-#line 1944 "../wisitoken_grammar_re2c.c"
+#line 1950 "../wisitoken_grammar_re2c.c"
yy86:
YYDEBUG(86, YYPEEK ());
YYSKIP ();
@@ -2109,9 +2115,9 @@ yy88:
}
yy89:
YYDEBUG(89, YYPEEK ());
-#line 252 "../wisitoken_grammar.re2c"
+#line 258 "../wisitoken_grammar.re2c"
{*id = 35; continue;}
-#line 2115 "../wisitoken_grammar_re2c.c"
+#line 2121 "../wisitoken_grammar_re2c.c"
yy90:
YYDEBUG(90, YYPEEK ());
YYSKIP ();
@@ -2639,9 +2645,9 @@ yy97:
}
yy99:
YYDEBUG(99, YYPEEK ());
-#line 219 "../wisitoken_grammar.re2c"
+#line 225 "../wisitoken_grammar.re2c"
{*id = 2; continue;}
-#line 2645 "../wisitoken_grammar_re2c.c"
+#line 2651 "../wisitoken_grammar_re2c.c"
yy100:
YYDEBUG(100, YYPEEK ());
YYSKIP ();
@@ -3118,9 +3124,9 @@ yy108:
}
yy109:
YYDEBUG(109, YYPEEK ());
-#line 222 "../wisitoken_grammar.re2c"
+#line 228 "../wisitoken_grammar.re2c"
{*id = 5; continue;}
-#line 3124 "../wisitoken_grammar_re2c.c"
+#line 3130 "../wisitoken_grammar_re2c.c"
yy110:
YYDEBUG(110, YYPEEK ());
yyaccept = 2;
@@ -3155,9 +3161,9 @@ yy113:
YYDEBUG(113, YYPEEK ());
YYSKIP ();
YYDEBUG(114, YYPEEK ());
-#line 231 "../wisitoken_grammar.re2c"
+#line 237 "../wisitoken_grammar.re2c"
{*id = 14; continue;}
-#line 3161 "../wisitoken_grammar_re2c.c"
+#line 3167 "../wisitoken_grammar_re2c.c"
yy115:
YYDEBUG(115, YYPEEK ());
YYSKIP ();
@@ -3624,9 +3630,9 @@ yy122:
}
yy123:
YYDEBUG(123, YYPEEK ());
-#line 221 "../wisitoken_grammar.re2c"
+#line 227 "../wisitoken_grammar.re2c"
{*id = 4; continue;}
-#line 3630 "../wisitoken_grammar_re2c.c"
+#line 3636 "../wisitoken_grammar_re2c.c"
yy124:
YYDEBUG(124, YYPEEK ());
yyaccept = 2;
@@ -3783,9 +3789,9 @@ yy127:
}
yy128:
YYDEBUG(128, YYPEEK ());
-#line 220 "../wisitoken_grammar.re2c"
+#line 226 "../wisitoken_grammar.re2c"
{*id = 3; continue;}
-#line 3789 "../wisitoken_grammar_re2c.c"
+#line 3795 "../wisitoken_grammar_re2c.c"
yy129:
YYDEBUG(129, YYPEEK ());
yyaccept = 2;
@@ -3962,9 +3968,9 @@ yy134:
}
yy135:
YYDEBUG(135, YYPEEK ());
-#line 225 "../wisitoken_grammar.re2c"
+#line 231 "../wisitoken_grammar.re2c"
{*id = 8; continue;}
-#line 3968 "../wisitoken_grammar_re2c.c"
+#line 3974 "../wisitoken_grammar_re2c.c"
yy136:
YYDEBUG(136, YYPEEK ());
yyaccept = 2;
@@ -4111,9 +4117,9 @@ yy138:
}
yy139:
YYDEBUG(139, YYPEEK ());
-#line 223 "../wisitoken_grammar.re2c"
+#line 229 "../wisitoken_grammar.re2c"
{*id = 6; continue;}
-#line 4117 "../wisitoken_grammar_re2c.c"
+#line 4123 "../wisitoken_grammar_re2c.c"
yy140:
YYDEBUG(140, YYPEEK ());
yyaccept = 2;
@@ -4280,20 +4286,18 @@ yy144:
}
yy145:
YYDEBUG(145, YYPEEK ());
-#line 224 "../wisitoken_grammar.re2c"
+#line 230 "../wisitoken_grammar.re2c"
{*id = 7; continue;}
-#line 4286 "../wisitoken_grammar_re2c.c"
+#line 4292 "../wisitoken_grammar_re2c.c"
}
-#line 256 "../wisitoken_grammar.re2c"
+#line 262 "../wisitoken_grammar.re2c"
- }
+ }
+ /* lexer->cursor and lexer ->char_pos are one char past end of token */
*byte_position = lexer->byte_token_start - lexer->buffer + 1;
*byte_length = lexer->cursor - lexer->byte_token_start;
*char_position = lexer->char_token_start;
- if (DO_COUNT)
- *char_length = lexer->char_pos - lexer->char_token_start;
- else
- *char_length = lexer->char_pos - lexer->char_token_start + 1;
- *line_start = lexer->line_token_start;
+ *char_length = lexer->char_pos - lexer->char_token_start;
+ *line_start = lexer->line_token_start;
return status;
}
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [elpa] master 9014381: Release ada-mode 7.0.1, wisi 3.0.1,
Stephen Leake <=