[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[elpa] externals/wisitoken-grammar-mode e5d353c 2/2: * run_wisitoken_gra
|
From: |
Stephen Leake |
|
Subject: |
[elpa] externals/wisitoken-grammar-mode e5d353c 2/2: * run_wisitoken_grammar_parse.ads: New file. |
|
Date: |
Tue, 13 Aug 2019 19:09:45 -0400 (EDT) |
branch: externals/wisitoken-grammar-mode
commit e5d353c2255b905f98bc7bbd53c2d7c0d64d228c
Author: Stephen Leake <address@hidden>
Commit: Stephen Leake <address@hidden>
* run_wisitoken_grammar_parse.ads: New file.
* wisi-wisitoken_grammar.adb: New file.
* wisi-wisitoken_grammar.ads: New file.
* wisitoken-grammar-mmm.el: New file.
* wisitoken-grammar-mode.el: New file.
* wisitoken_grammar.gpr: New file.
* wisitoken_grammar_1.wy: New file.
* wisitoken_grammar_1_process_actions.adb: New file.
* wisitoken_grammar_1_process_actions.ads: New file.
* wisitoken_grammar_1_process_main.adb: New file.
* wisitoken_grammar_1_process_main.ads: New file.
* wisitoken_grammar_1_re2c.c: New file.
* wisitoken_grammar_1_re2c_c.ads: New file.
* wisitoken_grammar_mode_parse.ads: New file.
---
run_wisitoken_grammar_parse.ads | 29 +
wisi-wisitoken_grammar.adb | 66 +
wisi-wisitoken_grammar.ads | 44 +
wisitoken-grammar-mmm.el | 29 +
wisitoken-grammar-mode.el | 370 +++
wisitoken_grammar.gpr | 74 +
wisitoken_grammar_1.wy | 287 +++
wisitoken_grammar_1_process_actions.adb | 346 +++
wisitoken_grammar_1_process_actions.ads | 257 ++
wisitoken_grammar_1_process_main.adb | 1706 ++++++++++++
wisitoken_grammar_1_process_main.ads | 36 +
wisitoken_grammar_1_re2c.c | 4299 +++++++++++++++++++++++++++++++
wisitoken_grammar_1_re2c_c.ads | 63 +
wisitoken_grammar_mode_parse.ads | 34 +
14 files changed, 7640 insertions(+)
diff --git a/run_wisitoken_grammar_parse.ads b/run_wisitoken_grammar_parse.ads
new file mode 100644
index 0000000..678cdf0
--- /dev/null
+++ b/run_wisitoken_grammar_parse.ads
@@ -0,0 +1,29 @@
+-- Abstract :
+--
+-- Run the wisitoken-grammar parser standalone. Useful for debugging grammar
issues.
+--
+-- Copyright (C) 2017 - 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 Wisitoken_Grammar_1_Process_Actions;
+with Wisitoken_Grammar_1_Process_Main;
+with Gen_Run_Wisi_LR_Parse;
+with Wisi.WisiToken_Grammar;
+procedure Run_WisiToken_Grammar_Parse is new Gen_Run_Wisi_LR_Parse
+ (Wisi.WisiToken_Grammar.Parse_Data_Type,
+ Wisitoken_Grammar_1_Process_Actions.Descriptor,
+ null, null, null,
+ Wisitoken_Grammar_1_Process_Main.Create_Parser);
diff --git a/wisi-wisitoken_grammar.adb b/wisi-wisitoken_grammar.adb
new file mode 100644
index 0000000..a45fd78
--- /dev/null
+++ b/wisi-wisitoken_grammar.adb
@@ -0,0 +1,66 @@
+-- Abstract :
+--
+-- See spec.
+--
+-- Copyright (C) 2019 Stephen Leake All Rights Reserved.
+--
+-- 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
+-- Software Foundation; either version 3, or (at your option) any later
+-- version. This library is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN-
+-- TABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+-- As a special exception under Section 7 of GPL version 3, you are granted
+-- additional permissions described in the GCC Runtime Library Exception,
+-- version 3.1, as published by the Free Software Foundation.
+
+pragma License (Modified_GPL);
+
+with Wisitoken_Grammar_1_Process_Actions;
+package body Wisi.WisiToken_Grammar is
+
+ Check_Parens_Action_Index : constant String := "0";
+
+ overriding
+ procedure Initialize
+ (Data : in out Parse_Data_Type;
+ Lexer : in WisiToken.Lexer.Handle;
+ Descriptor : access constant WisiToken.Descriptor;
+ Source_File_Name : in String;
+ Post_Parse_Action : in Post_Parse_Action_Type;
+ Begin_Line : in WisiToken.Line_Number_Type;
+ End_Line : in WisiToken.Line_Number_Type;
+ Begin_Indent : in Integer;
+ Params : in String)
+ is
+ pragma Unreferenced (Params);
+ use all type Wisitoken_Grammar_1_Process_Actions.Token_Enum_ID;
+ begin
+ Wisi.Initialize
+ (Wisi.Parse_Data_Type (Data), Lexer, Descriptor, Source_File_Name,
Post_Parse_Action,
+ Begin_Line, End_Line, Begin_Indent, "");
+
+ Data.First_Comment_ID := +COMMENT_ID;
+ end Initialize;
+
+ procedure Check_Parens
+ (Data : in out Wisi.Parse_Data_Type'Class;
+ Tree : in WisiToken.Syntax_Trees.Tree;
+ Tree_Tokens : in WisiToken.Syntax_Trees.Valid_Node_Index_Array;
+ Args : in Arg_Index_Array)
+ is
+ use WisiToken;
+ begin
+ for Index of Args loop
+ declare
+ Token : Augmented_Token renames Data.Terminals
(Tree.Min_Terminal_Index (Tree_Tokens (Index)));
+ begin
+ Data.Put_Language_Action
+ (Check_Parens_Action_Index & Buffer_Pos'Image
(Token.Char_Region.First) &
+ Buffer_Pos'Image (Token.Char_Region.Last));
+ end;
+ end loop;
+ end Check_Parens;
+
+end Wisi.WisiToken_Grammar;
diff --git a/wisi-wisitoken_grammar.ads b/wisi-wisitoken_grammar.ads
new file mode 100644
index 0000000..d2c3e5d
--- /dev/null
+++ b/wisi-wisitoken_grammar.ads
@@ -0,0 +1,44 @@
+-- Abstract :
+--
+-- Wisitoken_grammar parser language-specific runtime
+--
+-- Copyright (C) 2019 Stephen Leake All Rights Reserved.
+--
+-- 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
+-- Software Foundation; either version 3, or (at your option) any later
+-- version. This library is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN-
+-- TABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+-- As a special exception under Section 7 of GPL version 3, you are granted
+-- additional permissions described in the GCC Runtime Library Exception,
+-- version 3.1, as published by the Free Software Foundation.
+
+pragma License (Modified_GPL);
+
+package Wisi.WisiToken_Grammar is
+
+ Language_Protocol_Version : constant String := "1";
+
+ type Parse_Data_Type is new Wisi.Parse_Data_Type with null record;
+
+ overriding
+ procedure Initialize
+ (Data : in out Parse_Data_Type;
+ Lexer : in WisiToken.Lexer.Handle;
+ Descriptor : access constant WisiToken.Descriptor;
+ Source_File_Name : in String;
+ Post_Parse_Action : in Post_Parse_Action_Type;
+ Begin_Line : in WisiToken.Line_Number_Type;
+ End_Line : in WisiToken.Line_Number_Type;
+ Begin_Indent : in Integer;
+ Params : in String);
+
+ procedure Check_Parens
+ (Data : in out Wisi.Parse_Data_Type'Class;
+ Tree : in WisiToken.Syntax_Trees.Tree;
+ Tree_Tokens : in WisiToken.Syntax_Trees.Valid_Node_Index_Array;
+ Args : in Arg_Index_Array);
+
+end Wisi.WisiToken_Grammar;
diff --git a/wisitoken-grammar-mmm.el b/wisitoken-grammar-mmm.el
new file mode 100644
index 0000000..7c76b21
--- /dev/null
+++ b/wisitoken-grammar-mmm.el
@@ -0,0 +1,29 @@
+;;; Define multi-major-mode stuff for wisitoken-grammar mode. -*-
lexical-binding:t -*-
+
+(require 'mmm-mode)
+
+(mmm-add-classes
+ '((wisi-action
+ :match-submode wisitoken-grammar-mmm-submode
+ :face mmm-code-submode-face
+ :front "%("
+ :back ")%"
+ :insert ((?a wisi-action nil @ "%(" @ "" _ "" @ ")%")))
+ (wisi-code
+ :match-submode wisi-mmm-submode
+ :face mmm-code-submode-face
+ :front "%{"
+ :back "}%"
+ :insert ((?a wisi-code nil @ "%{" @ "" _ "" @ "}%")))
+ ))
+
+(defvar wisitoken-grammar-action-mode) ;; in wisitoken-grammar-mode.el
+(defun wisitoken-grammar-mmm-submode (_delim)
+ "for :match-submode"
+ wisitoken-grammar-action-mode)
+
+(add-to-list 'mmm-mode-ext-classes-alist '(wisitoken-grammar-mode nil
wisi-action))
+(add-to-list 'mmm-mode-ext-classes-alist '(wisitoken-grammar-mode nil
wisi-code))
+
+(provide 'wisitoken-grammar-mmm)
+;;; end of file
diff --git a/wisitoken-grammar-mode.el b/wisitoken-grammar-mode.el
new file mode 100644
index 0000000..aab4ee7
--- /dev/null
+++ b/wisitoken-grammar-mode.el
@@ -0,0 +1,370 @@
+;;; wisitoken-grammar-mode.el --- Major mode for editing WisiToken grammar
files -*- lexical-binding:t -*-
+
+;; Copyright (C) 2017 - 2019 Free Software Foundation, Inc.
+
+;; Author: Stephen Leake <address@hidden>
+;; Maintainer: Stephen Leake <address@hidden>
+;; Keywords: languages
+;; Version: 1.0.0
+;; package-requires: ((wisi "2.1.1") (emacs "25.0") (mmm-mode "0.5.7"))
+
+;; (Gnu ELPA requires single digits between dots in versions)
+;; no ’url’; just ELPA
+
+;; This file is part of GNU Emacs.
+
+;; wisitoken-grammar-mode is free software; you can redistribute it and/or
modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 3, or (at your option)
+;; any later version.
+
+;; wisitoken-grammar-mode is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+;;
+;;; Commentary:
+
+(require 'cl-lib)
+(require 'xref)
+(require 'wisi)
+(require 'wisitoken_grammar_1-process)
+(require 'wisi-process-parse)
+
+(eval-and-compile
+ (when (locate-library "mmm-mode")
+ (require 'wisitoken-grammar-mmm)))
+
+(defgroup wisitoken-grammar nil
+ "Major mode for editing Wisi grammar files in Emacs."
+ :group 'languages)
+
+(defcustom wisitoken-grammar-process-parse-exec
"wisitoken_grammar_mode_parse.exe"
+ "Name of executable to use for external process wisitoken-grammar parser,"
+ :type 'string
+ :group 'wisitoken-grammar)
+
+(defvar wisitoken-grammar-mode-syntax-table
+ (let ((table (make-syntax-table)))
+ ;; see wisitoken-grammar-syntax-propertize for comment start
+ (modify-syntax-entry ?\n "> " table)
+ (modify-syntax-entry ?= ". " table) ;; default symbol
+ (modify-syntax-entry ?* ". " table) ;; default symbol
+ table))
+
+(defvar wisitoken-grammar-mode-map
+ (let ((map (make-sparse-keymap)))
+ ;; C-c <letter> are reserved for users
+
+ ;; comment-dwim is in global map on M-;
+ (define-key map "\C-c\C-f" 'wisi-show-parse-error)
+ (define-key map "\C-c\C-m" 'wisitoken-grammar-mmm-parse)
+ (define-key map [S-return] 'wisitoken-grammar-new-line)
+ map
+ ) "Local keymap used for wisitoken-grammar mode.")
+
+(defvar-local wisitoken-grammar-action-mode nil
+ "Emacs major mode used for actions and code, inferred from ’%generate’
declaration or file local variable.")
+
+(cl-defstruct (wisitoken-grammar-parser (:include wisi-process--parser))
+ ;; no new slots
+ )
+
+(cl-defmethod wisi-parse-format-language-options ((_parser
wisitoken-grammar-parser))
+ "")
+
+(defun wisitoken-grammar-check-parens (sexp)
+ "For `wisi-process--parse-Language'"
+ ;; sexp is [Language index token-first token-last]
+
+ ;; Check for missing parens in the action; otherwise only
+ ;; checked at grammar generation time.
+ (let* ((start (aref sexp 2))
+ (stop (1+ (aref sexp 3)))
+ (paren-depth-start (nth 0 (syntax-ppss start)))
+ (paren-depth-stop (nth 0 (syntax-ppss stop))))
+ ;; We could check for paren-depth = 0 at start, but then we'd
+ ;; get errors on every action after that.
+ (unless (= paren-depth-start paren-depth-stop)
+ (push
+ (make-wisi--parse-error
+ :pos (copy-marker start)
+ :message
+ (format "%s:%d: missing paren or bracket in %d %d"
+ (if (buffer-file-name) (file-name-nondirectory
(buffer-file-name)) "")
+ ;; file-name can be nil during vc-resolve-conflict
+ (line-number-at-pos start)
+ start stop))
+ (wisi-parser-parse-errors wisi--parser))
+
+ ;; As of mmm version 0.5.7, mmm-parse-region calls
+ ;; font-lock-ensure, which calls us. So we can't do
+ ;; mmm-parse-region here. FIXME: fix mmm to do parse-region in
+ ;; syntax-propertize.
+ )))
+
+(defun wisitoken-grammar-in-action-or-comment ()
+ ;; (info "(elisp) Parser State" "*info syntax-ppss*")
+ (let* ((state (syntax-ppss))
+ (paren-depth (nth 0 state))
+ (done nil)
+ (result nil))
+ (cond
+ ((nth 3 state)
+ ;; in string
+ t)
+
+ ((nth 4 state)
+ ;; in comment
+ t)
+
+ ((> paren-depth 0)
+ ;; check for action delimiters
+ (save-excursion
+ (while (not done)
+ (if (= ?% (char-before (nth 1 state)))
+ ;; in code, regexp, or action
+ (setq done t
+ result t)
+
+ ;; else go up one level
+ (setq state (syntax-ppss (1- (nth 1 state))))
+ )))
+ result)
+ )))
+
+(defun wisitoken-grammar-find-begin (begin)
+ "Starting at BEGIN, search backward for a parse start point."
+ (goto-char begin)
+ (cond
+ ((wisi-search-backward-skip "^%[^({[]\\|:"
#'wisitoken-grammar-in-action-or-comment)
+ (when (looking-at ":")
+ ;; Move back to before the nonterminal name
+ (forward-comment (- (line-number-at-pos (point))))
+ (skip-syntax-backward "w_"))
+ (point))
+
+ (t
+ (point-min))
+ ))
+
+(defun wisitoken-grammar-find-end (end)
+ "Starting at END, search forward for a parse end point."
+ (goto-char end)
+ (cond
+ ((wisi-search-forward-skip "^%\\|;$"
#'wisitoken-grammar-in-action-or-comment)
+ (point))
+
+ (t
+ (point-max))
+ ))
+
+(cl-defmethod wisi-parse-expand-region ((_parser wisitoken-grammar-parser)
begin end)
+ (save-excursion
+ (let ((begin-cand (wisitoken-grammar-find-begin begin))
+ (end-cand (wisitoken-grammar-find-end end)))
+ (cons begin-cand end-cand)
+ )))
+
+(defun wisitoken-grammar-mmm-parse ()
+ "If in action, call `mmm-parse-region' on it."
+ (interactive)
+ (save-excursion
+ (let* ((begin (search-backward-regexp "%[(}]" nil t))
+ (end (when begin (search-forward-regexp "[)}]%" nil t))))
+ (when (and begin end)
+ (mmm-parse-region begin end)))
+ ))
+
+(defun wisitoken-grammar-new-line ()
+ "If in comment, insert new comment line.
+If in nonterminal, insert new production right hand side.
+Otherwise insert a plain new line."
+ (interactive)
+ (if (nth 4 (syntax-ppss))
+ ;; in comment
+ (comment-indent-new-line)
+
+ (let ((pos (point))
+ (cache (save-excursion (wisi-goto-statement-start))))
+ (if (and cache
+ (eq (wisi-cache-nonterm cache) 'nonterminal)
+ (wisi-cache-end cache)
+ (> (wisi-cache-end cache) pos))
+ (progn
+ ;; in nonterminal
+ (insert "\n| ")
+ (indent-according-to-mode))
+
+ (newline-and-indent)
+ ))
+ ))
+
+(defun wisitoken-grammar-which-function ()
+ "For `which-func-functions', `add-log-current-defun-function'."
+ (wisi-validate-cache (point-min) (point-max) nil 'navigate)
+ ;; no message on parse fail, since this could be called from which-func-mode
+ (when (wisi-cache-covers-pos 'navigate (point))
+ (save-excursion
+ (wisi-goto-statement-start)
+ (wisi-next-name))))
+
+(defun wisitoken-grammar-add-log-current-function ()
+ "For `add-log-current-defun-function'; return name of current non-terminal
or declaration."
+ ;; add-log-current-defun is typically called with point at the start
+ ;; of an ediff change section, which is before the start of the
+ ;; declaration of a new item. So go to the end of the current line
+ ;; first
+ (save-excursion
+ (end-of-line 1)
+ (wisitoken-grammar-which-function)))
+
+(defun wisitoken-grammar-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
+ (concat
+ "\\(;;\\)" ;; comment start
+ "\\|\\(%\\[\\)" ;; regexp begin
+ )
+ end t)
+ (cond
+ ((match-beginning 1)
+ (put-text-property (match-beginning 1) (match-end 1) 'syntax-table
'(11 . nil)))
+
+ ((match-beginning 2)
+ (let ((begin (match-beginning 2))
+ (end (search-forward "]%")))
+ ;; allow single quotes in regexp to not mess up the rest of the
buffer
+ (put-text-property begin end 'syntax-table '(11 . nil))
+ ))
+ ))
+ )))
+
+(defun wisitoken-grammar-set-action-mode ()
+ (save-excursion
+ (goto-char (point-min))
+ (if (search-forward-regexp "%generate +\\([A-Za-z_0-9]+\\)
*\\([A-Za-z_0-9]+\\)?" (point-max) t)
+ (cond
+ ((string-equal (match-string 1) "None")
+ ;; unit test
+ (setq wisitoken-grammar-action-mode 'emacs-lisp-mode))
+
+ ((or
+ (string-equal (match-string 2) "Ada_Emacs")
+ (string-equal (match-string 2) "Elisp")
+ (string-equal (match-string 2) "elisp"))
+ (setq wisitoken-grammar-action-mode 'emacs-lisp-mode))
+
+ ((string-equal (match-string 2) "Ada")
+ (setq wisitoken-grammar-action-mode 'ada-mode))
+
+ (t
+ (error "unrecognized output language %s" (match-string 2)))
+ )
+
+ ;; We can still support the grammar statements, just not the actions.
+ (setq wisitoken-grammar-action-mode 'nil))))
+
+
+;;; xref integration
+(defun wisitoken-grammar--xref-backend ()
+ 'wisitoken-grammar)
+
+(cl-defmethod xref-backend-identifier-at-point ((_backend (eql
wisitoken-grammar)))
+ (wisi-xref-identifier-at-point))
+
+(cl-defmethod xref-backend-identifier-completion-table ((_backend (eql
wisitoken-grammar)))
+ (wisi-xref-identifier-completion-table))
+
+(cl-defmethod xref-backend-definitions ((_backend (eql wisitoken-grammar))
identifier)
+ (unless (and (string-match wisi-xref-ident-regexp identifier)
+ (match-string 2 identifier))
+ ;; Identifier is from identifier-at-point; get line from completion table
+ (setq identifier (try-completion identifier
(wisi-xref-identifier-completion-table)))
+ (unless (test-completion identifier
(wisi-xref-identifier-completion-table))
+ (setq identifier (completing-read "decl: "
(wisi-xref-identifier-completion-table) nil t identifier)))
+ (string-match wisi-xref-ident-regexp identifier))
+
+ (let* ((ident (match-string 1 identifier))
+ (line-str (match-string 2 identifier))
+ (line (when line-str (string-to-number line-str))))
+ (when line
+ (list (xref-make ident (xref-make-file-location (buffer-file-name) line
0))))
+ ))
+
+;;; debug
+(defun wisitoken-grammar-set-exec (exec-file)
+ "Set EXEC-FILE for current and future wisitoken-grammar parsers."
+ (interactive "f")
+ (setq wisitoken-grammar-process-parse-exec exec-file)
+ (wisi-process-parse-set-exec "wisitoken-grammar" exec-file))
+
+;;;;
+;;;###autoload
+(define-derived-mode wisitoken-grammar-mode prog-mode "Wisi"
+ "A major mode for Wisi grammar files."
+ (set (make-local-variable 'syntax-propertize-function)
'wisitoken-grammar-syntax-propertize)
+ (syntax-ppss-flush-cache (point-min));; reparse with new function
+ (set (make-local-variable 'parse-sexp-ignore-comments) t)
+ (set (make-local-variable 'parse-sexp-lookup-properties) t)
+
+ (set (make-local-variable 'comment-start) ";;")
+ (set (make-local-variable 'comment-end) "") ;; setting this to \n causes
errors
+ (set (make-local-variable 'comment-use-syntax) t);; the automatic test for
this does not use syntax-propertize
+ (set (make-local-variable 'comment-start-skip) ";;*[ \t]*")
+ (set (make-local-variable 'comment-multi-line) nil)
+ (set (make-local-variable 'require-final-newline) t)
+ (set (make-local-variable 'add-log-current-defun-function)
+ #'wisitoken-grammar-add-log-current-function)
+
+ (wisitoken-grammar-set-action-mode)
+
+ (add-hook 'xref-backend-functions #'wisitoken-grammar--xref-backend
+ nil ;; append
+ t)
+ (add-hook 'before-save-hook 'delete-trailing-whitespace nil t)
+ (add-hook 'before-save-hook 'copyright-update nil t)
+
+ (wisi-setup
+ :indent-calculate nil
+ :post-indent-fail nil
+ :parser (wisi-process-parse-get
+ (make-wisitoken-grammar-parser
+ :label "wisitoken-grammar"
+ :language-protocol-version "1"
+ :exec-file wisitoken-grammar-process-parse-exec
+ :face-table wisitoken_grammar_1-process-face-table
+ :token-table wisitoken_grammar_1-process-token-table
+ :language-action-table [wisitoken-grammar-check-parens]
+ ))
+ :lexer nil)
+
+ ;; Our wisi parser does not fontify comments and strings, so tell
+ ;; font-lock to do that.
+ (setq font-lock-defaults
+ '(nil ;; keywords
+ nil ;; keywords-only
+ ))
+ )
+
+;;;###autoload
+(add-to-list 'auto-mode-alist '("\\.wy\\'" . wisitoken-grammar-mode))
+
+(put 'wisitoken-grammar-mode 'custom-mode-group 'wisitoken-grammar)
+
+(provide 'wisitoken-grammar-mode)
+;;; wisitoken-grammar-mode.el ends here
diff --git a/wisitoken_grammar.gpr b/wisitoken_grammar.gpr
new file mode 100644
index 0000000..ce95959
--- /dev/null
+++ b/wisitoken_grammar.gpr
@@ -0,0 +1,74 @@
+-- Abstract :
+--
+-- build executables
+--
+-- Copyright (C) 2017 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.
+
+with "wisi_runtime";
+with "wisitoken";
+with "standard_common";
+project WisiToken_Grammar is
+
+ for Main use
+ ("wisitoken_grammar_mode_parse.ads",
+ "run_wisitoken_grammar_parse.ads"
+ );
+
+ for Source_Dirs use (".");
+
+ case Standard_Common.Profile is
+ when "On" =>
+ for Object_Dir use "obj_pro";
+ for Exec_Dir use "exec_pro";
+
+ when "Off" =>
+ for Object_Dir use "obj";
+ for Exec_Dir use ".";
+ end case;
+
+ for Languages use ("Ada", "C");
+
+ package Compiler is
+
+ case Standard_Common.Build is
+ when "Debug" =>
+ for Default_Switches ("Ada") use
+ Standard_Common.Compiler.Common_Switches &
+ Standard_Common.Compiler.Style_Checks &
+ Standard_Common.Compiler.Debug_Switches;
+
+ for Default_Switches ("C") use
Standard_Common.Compiler.Debug_Switches_C;
+
+ when "Normal" =>
+ for Default_Switches ("Ada") use
+ Standard_Common.Compiler.Common_Switches &
+ Standard_Common.Compiler.Style_Checks &
+ Standard_Common.Compiler.Release_Switches;
+
+ for Default_Switches ("C") use
Standard_Common.Compiler.Release_Switches_C;
+ end case;
+
+ end Compiler;
+
+ package Builder is
+ -- We use ".exe" extension even on non-Windows, to simplify the
makefiles.
+ for Executable_Suffix use ".exe";
+ end Builder;
+
+ package Binder is
+ for default_switches ("Ada") use ("-E"); -- symbolic traceback
+ end Binder;
+
+end WisiToken_Grammar;
diff --git a/wisitoken_grammar_1.wy b/wisitoken_grammar_1.wy
new file mode 100644
index 0000000..784fe48
--- /dev/null
+++ b/wisitoken_grammar_1.wy
@@ -0,0 +1,287 @@
+;;; WisiToken grammar for WisiToken grammar, for Emacs wisitoken-grammar mode.
+;;
+;; WisiToken uses the same grammar for parsing .wy files, but with
+;; different actions.
+;; (ediff "wisitoken_grammar_1.wy" "../org.wisitoken/wisitoken_grammar.wy")
+;;
+;; The supported syntax is similar to several flavors of Extended
+;; Backus-Naur form, as defined by
+;; https://en.wikipedia.org/wiki/Extended_Backus%E2%80%93Naur_form
+;;
+;; In particular, we support grammars for popular languages:
+;;
+;; - the Python grammar file given at
+;; https://docs.python.org/3.8/reference/grammar.html
+;;
+;; - the Java grammar file given at
+;; https://github.com/antlr/grammars-v4/tree/master/java
+;;
+;; - the Ada grammar given in the Ada Language Reference Manual Annex
+;; P; see http://ada-auth.org/arm.html
+;;
+;; This file uses only plain BNF syntax, to simplify working on the
+;; EBNF syntax.
+
+%code copyright_license %{
+;; 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/>.
+}%
+
+%code actions spec post %{
+ Partial_Parse_Active : Boolean := False;
+ Partial_Parse_Byte_Goal : WisiToken.Buffer_Pos := WisiToken.Buffer_Pos'Last;
+}%
+
+%meta_syntax EBNF
+
+;; LR1 for better error correction
+%generate LR1 Ada_Emacs re2c Process
+%start compilation_unit_list
+
+%language_runtime "Wisi.WisiToken_Grammar"
+
+%keyword CODE "code"
+%keyword END "end"
+%keyword IF "if"
+%keyword KEYWORD "keyword"
+%keyword NON_GRAMMAR "non_grammar"
+%keyword TOKEN "token"
+
+%token <delimited-text> RAW_CODE "%{" "}%"
+%token <delimited-text> REGEXP "%[" "]%"
+%token <delimited-text> ACTION "%(" ")%"
+
+%token <punctuation> BAR "|"
+%token <punctuation> COLON ":"
+%token <punctuation> COLON_COLON_EQUAL "::="
+%token <punctuation> COMMA ","
+%token <punctuation> EQUAL "="
+%token <punctuation> GREATER ">"
+%token <punctuation> LEFT_BRACE "{"
+%token <punctuation> LEFT_BRACKET "["
+%token <punctuation> LEFT_PAREN "("
+%token <punctuation> LESS "<"
+%token <punctuation> MINUS "-" ;; for {}-
+%token <punctuation> PERCENT "%"
+%token <punctuation> PLUS "+" ;; for ()+
+%token <punctuation> QUESTION "?" ;; for ()? same as []
+%token <punctuation> RIGHT_BRACE "}"
+%token <punctuation> RIGHT_BRACKET "]"
+%token <punctuation> RIGHT_PAREN ")"
+%token <punctuation> SEMICOLON ";"
+%token <punctuation> SLASH "/"
+%token <punctuation> STAR "*" ;; for ()* same as {}
+
+%token <number> NUMERIC_LITERAL %[ [0-9-][0-9_]* ]% "1234567890"
+%token <symbol> IDENTIFIER %[
[a-zA-Z\x80-\U0010FFFF][-0-9a-zA-Z_\x80-\U0010FFFF]* ]% "bogus"
+
+;; In re2c regexps, '...' indicates a case-insensitive match.
+;;
+;; In nonterminals, '...' indicates a literal, which we translate to a
+;; token; case-sensitive is then determined by the 'case_insensitive'
+;; declaration.
+;;
+;; 0x22 = "
+;; 0x27 = '
+%token <string-double> STRING_LITERAL_1 %[
(["][\x20-\x21\x23-\U0010FFFF]*["])+ ]% '""'
+%token <string-single> STRING_LITERAL_2 %[
(['][\x20-\x26\x28-\U0010FFFF]*['])+ ]% "''"
+
+%non_grammar <non-reporting> WHITESPACE %[ [ \t] ]%
+%non_grammar <new-line> NEW_LINE %[ [\x0a]|[\x0d][\x0a] ]%
+%non_grammar <comment> COMMENT %[ ";;"[^\x0a\x04]* ]%
+
+%elisp_face font-lock-constant-face
+%elisp_face font-lock-function-name-face
+%elisp_face font-lock-keyword-face
+%elisp_face font-lock-string-face
+%elisp_face font-lock-type-face
+%elisp_face nil
+
+%elisp_action face wisi-check-parens Check_Parens
+
+%mckenzie_cost_default 2 2 2 2
+%mckenzie_cost_insert SEMICOLON 1
+%mckenzie_enqueue_limit 10_000
+%mckenzie_check_limit 4
+
+%conflict SHIFT/REDUCE in state declaration, declaration on token IDENTIFIER
+%conflict SHIFT/REDUCE in state declaration_item_list, declaration on token
IDENTIFIER
+%conflict SHIFT/REDUCE in state nonterminal, nonterminal on token IDENTIFIER
+%conflict SHIFT/REDUCE in state rhs_list, nonterminal on token PERCENT
+%conflict SHIFT/REDUCE in state rhs_item_list, rhs on token IDENTIFIER
+%conflict SHIFT/REDUCE in state rhs_list, rhs_list on token IDENTIFIER
+
+;;;; grammar rules, no particular order
+
+declaration
+ : PERCENT token_keyword_non_grammar IDENTIFIER declaration_item_list
+ %((progn
+ (wisi-statement-action [1 statement-start])
+ (wisi-name-action 3)
+ (wisi-face-apply-action
+ [1 nil font-lock-constant-face
+ 2 nil font-lock-keyword-face
+ 3 nil font-lock-function-name-face])
+ (wisi-indent-action [nil nil nil (wisi-hanging 4 2)])))%
+ | PERCENT CODE identifier_list RAW_CODE
+ %( (wisi-face-apply-action [1 nil font-lock-constant-face 2 nil
font-lock-keyword-face]) )%
+ | PERCENT IDENTIFIER declaration_item_list
+ %((progn
+ (wisi-face-apply-action [1 nil font-lock-constant-face 2 nil
font-lock-keyword-face])
+ (wisi-indent-action [nil nil (wisi-hanging 4 2)])))%
+ | PERCENT IDENTIFIER
+ %( (wisi-face-apply-action [1 nil font-lock-constant-face 2 nil
font-lock-keyword-face]) )%
+ | PERCENT IF IDENTIFIER EQUAL IDENTIFIER
+ %( (wisi-face-apply-action [1 nil font-lock-constant-face 2 nil
font-lock-keyword-face]) )%
+ | PERCENT END IF
+ %( (wisi-face-apply-action [1 nil font-lock-constant-face 2 nil
font-lock-keyword-face 3 nil
+ font-lock-keyword-face]) )%
+ ;
+
+token_keyword_non_grammar
+ : KEYWORD
+ | NON_GRAMMAR LESS IDENTIFIER GREATER
+ %( (wisi-face-apply-action [3 nil font-lock-type-face]) )%
+ | TOKEN LESS IDENTIFIER GREATER
+ %( (wisi-face-apply-action [3 nil font-lock-type-face]) )%
+ ;
+
+identifier_list
+ : IDENTIFIER
+ | identifier_list IDENTIFIER
+ ;
+
+declaration_item_list
+ : declaration_item
+ | declaration_item_list declaration_item
+ ;
+
+declaration_item
+ : COMMA
+ | IDENTIFIER
+ | EQUAL
+ | LEFT_PAREN
+ | NUMERIC_LITERAL
+ | REGEXP
+ %((wisi-face-apply-action [1 nil font-lock-string-face]))%
+ | RIGHT_PAREN
+ | SLASH
+ | STRING_LITERAL_1
+ | STRING_LITERAL_2
+ | TOKEN
+ ;; ",", "token", "/", "(", ")" appear in %conflict declarations
+ ;
+
+nonterminal
+ : IDENTIFIER (COLON | COLON_COLON_EQUAL) rhs_list semicolon_opt
+ %( (progn
+ (wisi-statement-action [1 statement-start 4 statement-end])
+ (wisi-name-action 1)
+ (wisi-face-apply-action [1 nil font-lock-function-name-face])
+ (wisi-indent-action [nil 2 2 2])) )%
+ ;
+
+semicolon_opt :
+;; Terminating semicolon optional for Python grammar syntax (see
+;; header comments).
+ SEMICOLON | ;
+
+rhs_list
+ : rhs
+ %((wisi-indent-action [[2 nil]]))%
+ | rhs_list BAR rhs
+ %((wisi-indent-action [nil nil 2]))%
+ | rhs_list PERCENT IF IDENTIFIER EQUAL IDENTIFIER
+ | rhs_list PERCENT END IF
+ ;
+
+rhs
+ : ;; empty
+ | rhs_item_list
+ %((wisi-indent-action [[(wisi-hanging nil 2) nil]]))%
+ | rhs_item_list ACTION
+ %((wisi-check-parens [2]))%
+ | rhs_item_list ACTION ACTION
+ %((wisi-check-parens [2 3]))%
+ ;
+
+rhs_attribute
+ : LESS IDENTIFIER EQUAL IDENTIFIER GREATER
+ ;
+
+rhs_element
+ : rhs_item
+ | IDENTIFIER EQUAL rhs_item
+ ;
+
+rhs_item_list
+ : rhs_element
+ | rhs_item_list rhs_element
+ ;
+
+rhs_item
+ : IDENTIFIER
+ | STRING_LITERAL_2 ;; value of token
+ | rhs_attribute ;; ANTLR attribute
+ | rhs_optional_item
+ | rhs_multiple_item
+ | rhs_group_item
+ ;
+
+rhs_group_item
+ : LEFT_PAREN rhs_alternative_list RIGHT_PAREN
+ ;
+
+rhs_optional_item
+ : LEFT_BRACKET rhs_alternative_list RIGHT_BRACKET
+ | LEFT_PAREN rhs_alternative_list RIGHT_PAREN QUESTION
+ | IDENTIFIER QUESTION
+ | STRING_LITERAL_2 QUESTION
+ ;
+
+rhs_multiple_item
+ : LEFT_BRACE rhs_alternative_list RIGHT_BRACE
+ | LEFT_BRACE rhs_alternative_list RIGHT_BRACE MINUS
+ | LEFT_PAREN rhs_alternative_list RIGHT_PAREN PLUS
+ | LEFT_PAREN rhs_alternative_list RIGHT_PAREN STAR
+ | IDENTIFIER PLUS
+ | IDENTIFIER STAR
+ ;
+
+rhs_alternative_list
+ : rhs_item_list
+ | rhs_alternative_list BAR rhs_item_list
+ ;
+
+;; We don't enforce a complete order, nor require all parts, so
+;; partial files can still be parsed successfully.
+compilation_unit
+ : declaration
+ | nonterminal
+ ;
+
+;; Compute indent for trailing comments.
+compilation_unit_list
+ : compilation_unit
+ %((wisi-indent-action [[0 0]]))%
+ | compilation_unit_list compilation_unit
+ %((wisi-indent-action [0 [0 0]]))%
+ ;
+
+;; end of file
diff --git a/wisitoken_grammar_1_process_actions.adb
b/wisitoken_grammar_1_process_actions.adb
new file mode 100644
index 0000000..692d9e1
--- /dev/null
+++ b/wisitoken_grammar_1_process_actions.adb
@@ -0,0 +1,346 @@
+-- generated parser support file.
+-- command line: wisitoken-bnf-generate.exe --generate LR1 Ada_Emacs re2c
PROCESS wisitoken_grammar_1.wy
+--
+
+-- 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/>.
+
+with Wisi; use Wisi;
+with Wisi.WisiToken_Grammar; use Wisi.WisiToken_Grammar;
+package body Wisitoken_Grammar_1_Process_Actions is
+
+
+ procedure declaration_0
+ (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 =>
+ Statement_Action (Parse_Data, Tree, Nonterm, Tokens, (1 => (1,
Statement_Start)));
+ Name_Action (Parse_Data, Tree, Nonterm, Tokens, 3);
+ when Face =>
+ Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, ((1, 5, 0), (2,
5, 2), (3, 5, 1)));
+ when Indent =>
+ Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple,
(Label => None))), (False, (Simple,
+ (Label => None))), (False, (Simple, (Label => None))), (False,
(Hanging_0, (Int, 4), (Int, 2)))));
+ end case;
+ end declaration_0;
+
+ procedure declaration_1
+ (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 =>
+ Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, ((1, 5, 0), (2,
5, 2)));
+ when Indent =>
+ null;
+ end case;
+ end declaration_1;
+
+ procedure declaration_2
+ (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 =>
+ Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, ((1, 5, 0), (2,
5, 2)));
+ when Indent =>
+ Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple,
(Label => None))), (False, (Simple,
+ (Label => None))), (False, (Hanging_0, (Int, 4), (Int, 2)))));
+ end case;
+ end declaration_2;
+
+ procedure declaration_3
+ (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 =>
+ Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, ((1, 5, 0), (2,
5, 2)));
+ when Indent =>
+ null;
+ end case;
+ end declaration_3;
+
+ procedure declaration_4
+ (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 =>
+ Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, ((1, 5, 0), (2,
5, 2)));
+ when Indent =>
+ null;
+ end case;
+ end declaration_4;
+
+ procedure declaration_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 =>
+ Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, ((1, 5, 0), (2,
5, 2), (3, 5, 2)));
+ when Indent =>
+ null;
+ end case;
+ end declaration_5;
+
+ procedure token_keyword_non_grammar_1
+ (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 =>
+ Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, (1 => (3, 5,
4)));
+ when Indent =>
+ null;
+ end case;
+ end token_keyword_non_grammar_1;
+
+ procedure token_keyword_non_grammar_2
+ (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 =>
+ Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, (1 => (3, 5,
4)));
+ when Indent =>
+ null;
+ end case;
+ end token_keyword_non_grammar_2;
+
+ procedure declaration_item_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 =>
+ Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, (1 => (1, 5,
3)));
+ when Indent =>
+ null;
+ end case;
+ end declaration_item_5;
+
+ procedure nonterminal_0
+ (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 =>
+ Statement_Action (Parse_Data, Tree, Nonterm, Tokens, ((1,
Statement_Start), (4, Statement_End)));
+ Name_Action (Parse_Data, Tree, Nonterm, Tokens, 1);
+ when Face =>
+ Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, (1 => (1, 5,
1)));
+ when Indent =>
+ Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple,
(Label => None))), (False, (Simple,
+ (Int, 2))), (False, (Simple, (Int, 2))), (False, (Simple, (Int,
2)))));
+ end case;
+ end nonterminal_0;
+
+ procedure rhs_list_0
+ (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,
(Simple, (Int, 2)), (Simple, (Label =>
+ None)))));
+ end case;
+ end rhs_list_0;
+
+ procedure rhs_list_1
+ (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))), (False, (Simple,
+ (Label => None))), (False, (Simple, (Int, 2)))));
+ end case;
+ end rhs_list_1;
+
+ procedure rhs_1
+ (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, 2)),
+ (Simple, (Label => None)))));
+ end case;
+ end rhs_1;
+
+ procedure rhs_2
+ (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);
+ pragma Unreferenced (Nonterm);
+ begin
+ case Parse_Data.Post_Parse_Action is
+ when Navigate =>
+ null;
+ when Face =>
+ Check_Parens (Wisi.Parse_Data_Type'Class (User_Data), Tree, Tokens,
(1 => 2));
+ when Indent =>
+ null;
+ end case;
+ end rhs_2;
+
+ procedure rhs_3
+ (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);
+ pragma Unreferenced (Nonterm);
+ begin
+ case Parse_Data.Post_Parse_Action is
+ when Navigate =>
+ null;
+ when Face =>
+ Check_Parens (Wisi.Parse_Data_Type'Class (User_Data), Tree, Tokens,
(2, 3));
+ when Indent =>
+ null;
+ end case;
+ end rhs_3;
+
+ procedure compilation_unit_list_0
+ (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,
(Simple, (Int, 0)), (Simple, (Int, 0)))));
+ end case;
+ end compilation_unit_list_0;
+
+ procedure compilation_unit_list_1
+ (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,
(Int, 0))), (True, (Simple, (Int, 0)),
+ (Simple, (Int, 0)))));
+ end case;
+ end compilation_unit_list_1;
+
+end Wisitoken_Grammar_1_Process_Actions;
diff --git a/wisitoken_grammar_1_process_actions.ads
b/wisitoken_grammar_1_process_actions.ads
new file mode 100644
index 0000000..fa66e90
--- /dev/null
+++ b/wisitoken_grammar_1_process_actions.ads
@@ -0,0 +1,257 @@
+-- generated parser support file.
+-- command line: wisitoken-bnf-generate.exe --generate LR1 Ada_Emacs re2c
PROCESS wisitoken_grammar_1.wy
+--
+
+-- 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/>.
+
+with WisiToken.Syntax_Trees;
+package Wisitoken_Grammar_1_Process_Actions is
+
+ Descriptor : aliased WisiToken.Descriptor :=
+ (First_Terminal => 3,
+ Last_Terminal => 36,
+ First_Nonterminal => 37,
+ Last_Nonterminal => 57,
+ EOI_ID => 36,
+ Accept_ID => 37,
+ Case_Insensitive => False,
+ New_Line_ID => 1,
+ String_1_ID => 35,
+ String_2_ID => 34,
+ Image =>
+ (new String'("WHITESPACE"),
+ new String'("NEW_LINE"),
+ new String'("COMMENT"),
+ new String'("CODE"),
+ new String'("END"),
+ new String'("IF"),
+ new String'("KEYWORD"),
+ new String'("NON_GRAMMAR"),
+ new String'("TOKEN"),
+ new String'("RAW_CODE"),
+ new String'("REGEXP"),
+ new String'("ACTION"),
+ new String'("BAR"),
+ new String'("COLON"),
+ new String'("COLON_COLON_EQUAL"),
+ new String'("COMMA"),
+ new String'("EQUAL"),
+ new String'("GREATER"),
+ new String'("LEFT_BRACE"),
+ new String'("LEFT_BRACKET"),
+ new String'("LEFT_PAREN"),
+ new String'("LESS"),
+ new String'("MINUS"),
+ new String'("PERCENT"),
+ new String'("PLUS"),
+ new String'("QUESTION"),
+ new String'("RIGHT_BRACE"),
+ new String'("RIGHT_BRACKET"),
+ new String'("RIGHT_PAREN"),
+ new String'("SEMICOLON"),
+ new String'("SLASH"),
+ new String'("STAR"),
+ new String'("NUMERIC_LITERAL"),
+ new String'("IDENTIFIER"),
+ new String'("STRING_LITERAL_1"),
+ new String'("STRING_LITERAL_2"),
+ new String'("Wisi_EOI"),
+ new String'("wisitoken_accept"),
+ new String'("declaration"),
+ new String'("token_keyword_non_grammar"),
+ new String'("identifier_list"),
+ new String'("declaration_item_list"),
+ new String'("declaration_item"),
+ new String'("nonterminal"),
+ new String'("semicolon_opt"),
+ new String'("rhs_list"),
+ new String'("rhs"),
+ new String'("rhs_attribute"),
+ new String'("rhs_element"),
+ new String'("rhs_item_list"),
+ new String'("rhs_item"),
+ new String'("rhs_group_item"),
+ new String'("rhs_optional_item"),
+ new String'("rhs_multiple_item"),
+ new String'("rhs_alternative_list"),
+ new String'("compilation_unit"),
+ new String'("compilation_unit_list"),
+ new String'("nonterminal_004")),
+ Terminal_Image_Width => 17,
+ Image_Width => 25,
+ Last_Lookahead => 36);
+
+ type Token_Enum_ID is
+ (WHITESPACE_ID,
+ NEW_LINE_ID,
+ COMMENT_ID,
+ CODE_ID,
+ END_ID,
+ IF_ID,
+ KEYWORD_ID,
+ NON_GRAMMAR_ID,
+ TOKEN_ID,
+ RAW_CODE_ID,
+ REGEXP_ID,
+ ACTION_ID,
+ BAR_ID,
+ COLON_ID,
+ COLON_COLON_EQUAL_ID,
+ COMMA_ID,
+ EQUAL_ID,
+ GREATER_ID,
+ LEFT_BRACE_ID,
+ LEFT_BRACKET_ID,
+ LEFT_PAREN_ID,
+ LESS_ID,
+ MINUS_ID,
+ PERCENT_ID,
+ PLUS_ID,
+ QUESTION_ID,
+ RIGHT_BRACE_ID,
+ RIGHT_BRACKET_ID,
+ RIGHT_PAREN_ID,
+ SEMICOLON_ID,
+ SLASH_ID,
+ STAR_ID,
+ NUMERIC_LITERAL_ID,
+ IDENTIFIER_ID,
+ STRING_LITERAL_1_ID,
+ STRING_LITERAL_2_ID,
+ Wisi_EOI_ID,
+ wisitoken_accept_ID,
+ declaration_ID,
+ token_keyword_non_grammar_ID,
+ identifier_list_ID,
+ declaration_item_list_ID,
+ declaration_item_ID,
+ nonterminal_ID,
+ semicolon_opt_ID,
+ rhs_list_ID,
+ rhs_ID,
+ rhs_attribute_ID,
+ rhs_element_ID,
+ rhs_item_list_ID,
+ rhs_item_ID,
+ rhs_group_item_ID,
+ rhs_optional_item_ID,
+ rhs_multiple_item_ID,
+ rhs_alternative_list_ID,
+ compilation_unit_ID,
+ compilation_unit_list_ID,
+ nonterminal_004_ID);
+
+ type Token_Enum_ID_Array is array (Positive range <>) of Token_Enum_ID;
+ use all type WisiToken.Token_ID;
+ function "+" (Item : in Token_Enum_ID) return WisiToken.Token_ID
+ is (WisiToken.Token_ID'First + Token_Enum_ID'Pos (Item));
+ function To_Token_Enum (Item : in WisiToken.Token_ID) return Token_Enum_ID
+ is (Token_Enum_ID'Val (Item - WisiToken.Token_ID'First));
+ function "-" (Item : in WisiToken.Token_ID) return Token_Enum_ID renames
To_Token_Enum;
+
+ procedure declaration_0
+ (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 declaration_1
+ (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 declaration_2
+ (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 declaration_3
+ (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 declaration_4
+ (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 declaration_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 token_keyword_non_grammar_1
+ (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 token_keyword_non_grammar_2
+ (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 declaration_item_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 nonterminal_0
+ (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 rhs_list_0
+ (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 rhs_list_1
+ (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 rhs_1
+ (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 rhs_2
+ (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 rhs_3
+ (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 compilation_unit_list_0
+ (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 compilation_unit_list_1
+ (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);
+
+ Partial_Parse_Active : Boolean := False;
+ Partial_Parse_Byte_Goal : WisiToken.Buffer_Pos := WisiToken.Buffer_Pos'Last;
+end Wisitoken_Grammar_1_Process_Actions;
diff --git a/wisitoken_grammar_1_process_main.adb
b/wisitoken_grammar_1_process_main.adb
new file mode 100644
index 0000000..b350248
--- /dev/null
+++ b/wisitoken_grammar_1_process_main.adb
@@ -0,0 +1,1706 @@
+-- generated parser support file.
+-- command line: wisitoken-bnf-generate.exe --generate LR1 Ada_Emacs re2c
PROCESS wisitoken_grammar_1.wy
+--
+
+-- 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/>.
+
+with Wisitoken_Grammar_1_Process_Actions; use
Wisitoken_Grammar_1_Process_Actions;
+with WisiToken.Lexer.re2c;
+with wisitoken_grammar_1_re2c_c;
+package body Wisitoken_Grammar_1_Process_Main is
+
+ package Lexer is new WisiToken.Lexer.re2c
+ (wisitoken_grammar_1_re2c_c.New_Lexer,
+ wisitoken_grammar_1_re2c_c.Free_Lexer,
+ wisitoken_grammar_1_re2c_c.Reset_Lexer,
+ wisitoken_grammar_1_re2c_c.Next_Token);
+
+ procedure Create_Parser
+ (Parser : out WisiToken.Parse.LR.Parser.Parser;
+ Language_Fixes : in
WisiToken.Parse.LR.Parser.Language_Fixes_Access;
+ Language_Matching_Begin_Tokens : in
WisiToken.Parse.LR.Parser.Language_Matching_Begin_Tokens_Access;
+ Language_String_ID_Set : in
WisiToken.Parse.LR.Parser.Language_String_ID_Set_Access;
+ Trace : not null access WisiToken.Trace'Class;
+ User_Data : in
WisiToken.Syntax_Trees.User_Data_Access)
+ is
+ use WisiToken.Parse.LR;
+ McKenzie_Param : constant McKenzie_Param_Type :=
+ (First_Terminal => 3,
+ Last_Terminal => 36,
+ First_Nonterminal => 37,
+ Last_Nonterminal => 57,
+ Insert =>
+ (2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2),
+ Delete =>
+ (2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2),
+ 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),
+ Undo_Reduce =>
+ (2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2),
+ Minimal_Complete_Cost_Delta => -1,
+ Fast_Forward => 0,
+ Matching_Begin => 0,
+ Ignore_Check_Fail => 2,
+ Task_Count => 0,
+ Check_Limit => 4,
+ Check_Delta_Limit => 2147483647,
+ Enqueue_Limit => 10000);
+
+ Table : constant Parse_Table_Ptr := new Parse_Table
+ (State_First => 0,
+ State_Last => 209,
+ First_Terminal => 3,
+ Last_Terminal => 36,
+ First_Nonterminal => 37,
+ Last_Nonterminal => 57);
+ begin
+ Table.McKenzie_Param := McKenzie_Param;
+ declare
+ procedure Subr_1
+ is begin
+ Table.States (0).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (0), 23, 1);
+ Add_Action (Table.States (0), 33, 2);
+ Table.States (0).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (0), 38, 3);
+ Add_Goto (Table.States (0), 43, 4);
+ Add_Goto (Table.States (0), 55, 5);
+ Add_Goto (Table.States (0), 56, 6);
+ Table.States (0).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 23, 1)));
+ Table.States (1).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (1), 3, 7);
+ Add_Action (Table.States (1), 4, 8);
+ Add_Action (Table.States (1), 5, 9);
+ Add_Action (Table.States (1), 6, 10);
+ Add_Action (Table.States (1), 7, 11);
+ Add_Action (Table.States (1), 8, 12);
+ Add_Action (Table.States (1), 33, 13);
+ Table.States (1).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (1), 39, 14);
+ Table.States (1).Kernel := To_Vector (((38, 23, 3, False), (38,
23, 3, False), (38, 23, 2, False), (38, 23,
+ 1, False), (38, 23, 4, False), (38, 23, 2, False)));
+ Table.States (1).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 13)));
+ Table.States (2).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (2), 13, 15);
+ Add_Action (Table.States (2), 14, 16);
+ Table.States (2).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (2), 57, 17);
+ Table.States (2).Kernel := To_Vector ((0 => (43, 33, 1, False)));
+ Table.States (2).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 13, 15)));
+ Table.States (3).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (3), (23, 33, 36), (55, 0), 1, null,
null);
+ Table.States (3).Kernel := To_Vector ((0 => (55, 38, 0, False)));
+ Table.States (3).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 55, 1)));
+ Table.States (4).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (4), (23, 33, 36), (55, 1), 1, null,
null);
+ Table.States (4).Kernel := To_Vector ((0 => (55, 43, 0, False)));
+ Table.States (4).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 55, 1)));
+ Table.States (5).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (5), (23, 33, 36), (56, 0), 1,
compilation_unit_list_0'Access, null);
+ Table.States (5).Kernel := To_Vector ((0 => (56, 55, 0, False)));
+ Table.States (5).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 56, 1)));
+ Table.States (6).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (6), 23, 1);
+ Add_Action (Table.States (6), 33, 2);
+ Add_Action (Table.States (6), 36, Accept_It, (37, 0), 1, null,
null);
+ Table.States (6).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (6), 38, 3);
+ Add_Goto (Table.States (6), 43, 4);
+ Add_Goto (Table.States (6), 55, 18);
+ Table.States (6).Kernel := To_Vector (((37, 56, 1, False), (56,
56, 2, True)));
+ Table.States (7).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (7), 33, 19);
+ Table.States (7).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (7), 40, 20);
+ Table.States (7).Kernel := To_Vector ((0 => (38, 3, 2, False)));
+ Table.States (7).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 19)));
+ Table.States (8).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (8), 5, 21);
+ Table.States (8).Kernel := To_Vector ((0 => (38, 4, 1, False)));
+ Table.States (8).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 5, 21)));
+ Table.States (9).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (9), 33, 22);
+ Table.States (9).Kernel := To_Vector ((0 => (38, 5, 3, False)));
+ Table.States (9).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 22)));
+ Table.States (10).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (10), (1 => 33), (39, 0), 1, null, null);
+ Table.States (10).Kernel := To_Vector ((0 => (39, 6, 0, False)));
+ Table.States (10).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 39, 1)));
+ Table.States (11).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (11), 21, 23);
+ Table.States (11).Kernel := To_Vector ((0 => (39, 7, 3, False)));
+ Table.States (11).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 21, 23)));
+ Table.States (12).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (12), 21, 24);
+ Table.States (12).Kernel := To_Vector ((0 => (39, 8, 3, False)));
+ Table.States (12).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 21, 24)));
+ Table.States (13).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (13), 8, 25);
+ Add_Action (Table.States (13), 10, 26);
+ Add_Action (Table.States (13), 15, 27);
+ Add_Action (Table.States (13), 16, 28);
+ Add_Action (Table.States (13), 20, 29);
+ Add_Action (Table.States (13), 23, Reduce, (38, 3), 2,
declaration_3'Access, null);
+ Add_Action (Table.States (13), 28, 30);
+ Add_Action (Table.States (13), 30, 31);
+ Add_Action (Table.States (13), 32, 32);
+ Add_Action (Table.States (13), 33, 33);
+ Add_Conflict (Table.States (13), 33, (38, 3), 2,
declaration_3'Access, null);
+ Add_Action (Table.States (13), 34, 34);
+ Add_Action (Table.States (13), 35, 35);
+ Add_Action (Table.States (13), 36, Reduce, (38, 3), 2,
declaration_3'Access, null);
+ Table.States (13).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (13), 41, 36);
+ Add_Goto (Table.States (13), 42, 37);
+ Table.States (13).Kernel := To_Vector (((38, 33, 1, False), (38,
33, 0, False)));
+ Table.States (13).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 38, 2)));
+ Table.States (14).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (14), 33, 38);
+ Table.States (14).Kernel := To_Vector ((0 => (38, 39, 2, False)));
+ Table.States (14).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 38)));
+ Table.States (15).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (15), (12, 18, 19, 20, 21, 23, 29, 33,
35, 36), (57, 0), 1, null, null);
+ Table.States (15).Kernel := To_Vector ((0 => (57, 13, 0, False)));
+ Table.States (15).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 57, 1)));
+ Table.States (16).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (16), (12, 18, 19, 20, 21, 23, 29, 33,
35, 36), (57, 1), 1, null, null);
+ Table.States (16).Kernel := To_Vector ((0 => (57, 14, 0, False)));
+ Table.States (16).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 57, 1)));
+ Table.States (17).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (17), 12, Reduce, (46, 0), 0, null, null);
+ Add_Action (Table.States (17), 18, 39);
+ Add_Action (Table.States (17), 19, 40);
+ Add_Action (Table.States (17), 20, 41);
+ Add_Action (Table.States (17), 21, 42);
+ Add_Action (Table.States (17), 23, Reduce, (46, 0), 0, null, null);
+ Add_Action (Table.States (17), 29, Reduce, (46, 0), 0, null, null);
+ Add_Action (Table.States (17), 33, 43);
+ Add_Conflict (Table.States (17), 33, (46, 0), 0, null, null);
+ Add_Action (Table.States (17), 35, 44);
+ Add_Action (Table.States (17), 36, Reduce, (46, 0), 0, null, null);
+ Table.States (17).Goto_List.Set_Capacity (9);
+ Add_Goto (Table.States (17), 45, 45);
+ Add_Goto (Table.States (17), 46, 46);
+ Add_Goto (Table.States (17), 47, 47);
+ Add_Goto (Table.States (17), 48, 48);
+ Add_Goto (Table.States (17), 49, 49);
+ Add_Goto (Table.States (17), 50, 50);
+ Add_Goto (Table.States (17), 51, 51);
+ Add_Goto (Table.States (17), 52, 52);
+ Add_Goto (Table.States (17), 53, 53);
+ Table.States (17).Kernel := To_Vector ((0 => (43, 57, 0, False)));
+ Table.States (17).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 45, 0)));
+ Table.States (18).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (18), (23, 33, 36), (56, 1), 2,
compilation_unit_list_1'Access, null);
+ Table.States (18).Kernel := To_Vector ((0 => (56, 55, 0, True)));
+ Table.States (18).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 56, 2)));
+ Table.States (18).Minimal_Complete_Actions_Recursive := True;
+ Table.States (19).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (19), (9, 33), (40, 0), 1, null, null);
+ Table.States (19).Kernel := To_Vector ((0 => (40, 33, 0, False)));
+ Table.States (19).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 40, 1)));
+ Table.States (20).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (20), 9, 54);
+ Add_Action (Table.States (20), 33, 55);
+ Table.States (20).Kernel := To_Vector (((38, 40, 1, False), (40,
40, 1, True)));
+ Table.States (20).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 9, 54)));
+ Table.States (21).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (21), (23, 33, 36), (38, 5), 3,
declaration_5'Access, null);
+ Table.States (21).Kernel := To_Vector ((0 => (38, 5, 0, False)));
+ Table.States (21).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 38, 3)));
+ Table.States (22).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (22), 16, 56);
+ Table.States (22).Kernel := To_Vector ((0 => (38, 33, 2, False)));
+ Table.States (22).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 16, 56)));
+ Table.States (23).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (23), 33, 57);
+ Table.States (23).Kernel := To_Vector ((0 => (39, 21, 2, False)));
+ Table.States (23).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 57)));
+ Table.States (24).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (24), 33, 58);
+ Table.States (24).Kernel := To_Vector ((0 => (39, 21, 2, False)));
+ Table.States (24).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 58)));
+ Table.States (25).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (25), (8, 10, 15, 16, 20, 23, 28, 30, 32,
33, 34, 35, 36), (42, 10), 1, null,
+ null);
+ Table.States (25).Kernel := To_Vector ((0 => (42, 8, 0, False)));
+ Table.States (25).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 42, 1)));
+ Table.States (26).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (26), (8, 10, 15, 16, 20, 23, 28, 30, 32,
33, 34, 35, 36), (42, 5), 1,
+ declaration_item_5'Access, null);
+ Table.States (26).Kernel := To_Vector ((0 => (42, 10, 0, False)));
+ Table.States (26).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 42, 1)));
+ Table.States (27).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (27), (8, 10, 15, 16, 20, 23, 28, 30, 32,
33, 34, 35, 36), (42, 0), 1, null,
+ null);
+ Table.States (27).Kernel := To_Vector ((0 => (42, 15, 0, False)));
+ Table.States (27).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 42, 1)));
+ Table.States (28).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (28), (8, 10, 15, 16, 20, 23, 28, 30, 32,
33, 34, 35, 36), (42, 2), 1, null,
+ null);
+ Table.States (28).Kernel := To_Vector ((0 => (42, 16, 0, False)));
+ Table.States (28).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 42, 1)));
+ Table.States (29).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (29), (8, 10, 15, 16, 20, 23, 28, 30, 32,
33, 34, 35, 36), (42, 3), 1, null,
+ null);
+ Table.States (29).Kernel := To_Vector ((0 => (42, 20, 0, False)));
+ Table.States (29).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 42, 1)));
+ Table.States (30).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (30), (8, 10, 15, 16, 20, 23, 28, 30, 32,
33, 34, 35, 36), (42, 6), 1, null,
+ null);
+ Table.States (30).Kernel := To_Vector ((0 => (42, 28, 0, False)));
+ Table.States (30).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 42, 1)));
+ Table.States (31).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (31), (8, 10, 15, 16, 20, 23, 28, 30, 32,
33, 34, 35, 36), (42, 7), 1, null,
+ null);
+ Table.States (31).Kernel := To_Vector ((0 => (42, 30, 0, False)));
+ Table.States (31).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 42, 1)));
+ Table.States (32).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (32), (8, 10, 15, 16, 20, 23, 28, 30, 32,
33, 34, 35, 36), (42, 4), 1, null,
+ null);
+ Table.States (32).Kernel := To_Vector ((0 => (42, 32, 0, False)));
+ Table.States (32).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 42, 1)));
+ Table.States (33).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (33), (8, 10, 15, 16, 20, 23, 28, 30, 32,
33, 34, 35, 36), (42, 1), 1, null,
+ null);
+ Table.States (33).Kernel := To_Vector ((0 => (42, 33, 0, False)));
+ Table.States (33).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 42, 1)));
+ Table.States (34).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (34), (8, 10, 15, 16, 20, 23, 28, 30, 32,
33, 34, 35, 36), (42, 8), 1, null,
+ null);
+ Table.States (34).Kernel := To_Vector ((0 => (42, 34, 0, False)));
+ Table.States (34).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 42, 1)));
+ Table.States (35).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (35), (8, 10, 15, 16, 20, 23, 28, 30, 32,
33, 34, 35, 36), (42, 9), 1, null,
+ null);
+ Table.States (35).Kernel := To_Vector ((0 => (42, 35, 0, False)));
+ Table.States (35).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 42, 1)));
+ Table.States (36).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (36), 8, 25);
+ Add_Action (Table.States (36), 10, 26);
+ Add_Action (Table.States (36), 15, 27);
+ Add_Action (Table.States (36), 16, 28);
+ Add_Action (Table.States (36), 20, 29);
+ Add_Action (Table.States (36), 23, Reduce, (38, 2), 3,
declaration_2'Access, null);
+ Add_Action (Table.States (36), 28, 30);
+ Add_Action (Table.States (36), 30, 31);
+ Add_Action (Table.States (36), 32, 32);
+ Add_Action (Table.States (36), 33, 33);
+ Add_Conflict (Table.States (36), 33, (38, 2), 3,
declaration_2'Access, null);
+ Add_Action (Table.States (36), 34, 34);
+ Add_Action (Table.States (36), 35, 35);
+ Add_Action (Table.States (36), 36, Reduce, (38, 2), 3,
declaration_2'Access, null);
+ Table.States (36).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (36), 42, 59);
+ Table.States (36).Kernel := To_Vector (((38, 41, 0, False), (41,
41, 1, True)));
+ Table.States (36).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 38, 3)));
+ Table.States (37).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (37), (8, 10, 15, 16, 20, 23, 28, 30, 32,
33, 34, 35, 36), (41, 0), 1, null,
+ null);
+ Table.States (37).Kernel := To_Vector ((0 => (41, 42, 0, False)));
+ Table.States (37).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 41, 1)));
+ Table.States (38).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (38), 8, 25);
+ Add_Action (Table.States (38), 10, 26);
+ Add_Action (Table.States (38), 15, 27);
+ Add_Action (Table.States (38), 16, 28);
+ Add_Action (Table.States (38), 20, 29);
+ Add_Action (Table.States (38), 28, 30);
+ Add_Action (Table.States (38), 30, 31);
+ Add_Action (Table.States (38), 32, 32);
+ Add_Action (Table.States (38), 33, 33);
+ Add_Action (Table.States (38), 34, 34);
+ Add_Action (Table.States (38), 35, 35);
+ Table.States (38).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (38), 41, 60);
+ Add_Goto (Table.States (38), 42, 37);
+ Table.States (38).Kernel := To_Vector ((0 => (38, 33, 1, False)));
+ Table.States (38).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 15, 27)));
+ Table.States (39).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (39), 18, 61);
+ Add_Action (Table.States (39), 19, 62);
+ Add_Action (Table.States (39), 20, 63);
+ Add_Action (Table.States (39), 21, 64);
+ Add_Action (Table.States (39), 33, 65);
+ Add_Action (Table.States (39), 35, 66);
+ Table.States (39).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (39), 47, 67);
+ Add_Goto (Table.States (39), 48, 68);
+ Add_Goto (Table.States (39), 49, 69);
+ Add_Goto (Table.States (39), 50, 70);
+ Add_Goto (Table.States (39), 51, 71);
+ Add_Goto (Table.States (39), 52, 72);
+ Add_Goto (Table.States (39), 53, 73);
+ Add_Goto (Table.States (39), 54, 74);
+ Table.States (39).Kernel := To_Vector (((53, 18, 2, False), (53,
18, 3, False)));
+ Table.States (39).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 65)));
+ Table.States (40).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (40), 18, 75);
+ Add_Action (Table.States (40), 19, 76);
+ Add_Action (Table.States (40), 20, 77);
+ Add_Action (Table.States (40), 21, 78);
+ Add_Action (Table.States (40), 33, 79);
+ Add_Action (Table.States (40), 35, 80);
+ Table.States (40).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (40), 47, 81);
+ Add_Goto (Table.States (40), 48, 82);
+ Add_Goto (Table.States (40), 49, 83);
+ Add_Goto (Table.States (40), 50, 84);
+ Add_Goto (Table.States (40), 51, 85);
+ Add_Goto (Table.States (40), 52, 86);
+ Add_Goto (Table.States (40), 53, 87);
+ Add_Goto (Table.States (40), 54, 88);
+ Table.States (40).Kernel := To_Vector ((0 => (52, 19, 2, False)));
+ Table.States (40).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 79)));
+ Table.States (41).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (41), 18, 89);
+ Add_Action (Table.States (41), 19, 90);
+ Add_Action (Table.States (41), 20, 91);
+ Add_Action (Table.States (41), 21, 92);
+ Add_Action (Table.States (41), 33, 93);
+ Add_Action (Table.States (41), 35, 94);
+ Table.States (41).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (41), 47, 95);
+ Add_Goto (Table.States (41), 48, 96);
+ Add_Goto (Table.States (41), 49, 97);
+ Add_Goto (Table.States (41), 50, 98);
+ Add_Goto (Table.States (41), 51, 99);
+ Add_Goto (Table.States (41), 52, 100);
+ Add_Goto (Table.States (41), 53, 101);
+ Add_Goto (Table.States (41), 54, 102);
+ Table.States (41).Kernel := To_Vector (((51, 20, 2, False), (52,
20, 3, False), (53, 20, 3, False), (53,
+ 20, 3, False)));
+ Table.States (41).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 93)));
+ Table.States (42).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (42), 33, 103);
+ Table.States (42).Kernel := To_Vector ((0 => (47, 21, 4, False)));
+ Table.States (42).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 103)));
+ Table.States (43).Action_List.Set_Capacity (15);
+ Add_Action (Table.States (43), 11, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (43), 12, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (43), 16, 104);
+ Add_Action (Table.States (43), 18, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (43), 19, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (43), 20, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (43), 21, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (43), 23, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (43), 24, 105);
+ Add_Action (Table.States (43), 25, 106);
+ Add_Action (Table.States (43), 29, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (43), 31, 107);
+ Add_Action (Table.States (43), 33, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (43), 35, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (43), 36, Reduce, (50, 0), 1, null, null);
+ Table.States (43).Kernel := To_Vector (((48, 33, 2, False), (50,
33, 0, False), (52, 33, 1, False), (53,
+ 33, 1, False), (53, 33, 1, False)));
+ Table.States (43).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (44).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (44), 11, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (44), 12, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (44), 18, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (44), 19, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (44), 20, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (44), 21, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (44), 23, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (44), 25, 108);
+ Add_Action (Table.States (44), 29, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (44), 33, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (44), 35, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (44), 36, Reduce, (50, 1), 1, null, null);
+ Table.States (44).Kernel := To_Vector (((50, 35, 0, False), (52,
35, 1, False)));
+ Table.States (44).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (45).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (45), 12, 109);
+ Add_Action (Table.States (45), 23, 110);
+ Add_Conflict (Table.States (45), 23, (44, 1), 0, null, null);
+ Add_Action (Table.States (45), 29, 111);
+ Add_Action (Table.States (45), 33, Reduce, (44, 1), 0, null, null);
+ Add_Action (Table.States (45), 36, Reduce, (44, 1), 0, null, null);
+ Table.States (45).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (45), 44, 112);
+ Table.States (45).Kernel := To_Vector (((43, 45, 0, False), (45,
45, 1, True), (45, 45, 5, True), (45, 45,
+ 3, True)));
+ Table.States (45).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 44, 0)));
+ Table.States (46).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (46), (12, 23, 29, 33, 36), (45, 0), 1,
rhs_list_0'Access, null);
+ Table.States (46).Kernel := To_Vector ((0 => (45, 46, 0, False)));
+ Table.States (46).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 45, 1)));
+ Table.States (47).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (47), (11, 12, 18, 19, 20, 21, 23, 29,
33, 35, 36), (50, 2), 1, null, null);
+ Table.States (47).Kernel := To_Vector ((0 => (50, 47, 0, False)));
+ Table.States (47).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (48).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (48), (11, 12, 18, 19, 20, 21, 23, 29,
33, 35, 36), (49, 0), 1, null, null);
+ Table.States (48).Kernel := To_Vector ((0 => (49, 48, 0, False)));
+ Table.States (48).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 49, 1)));
+ Table.States (49).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (49), 11, 113);
+ Add_Action (Table.States (49), 12, Reduce, (46, 1), 1,
rhs_1'Access, null);
+ Add_Action (Table.States (49), 18, 39);
+ Add_Action (Table.States (49), 19, 40);
+ Add_Action (Table.States (49), 20, 41);
+ Add_Action (Table.States (49), 21, 42);
+ Add_Action (Table.States (49), 23, Reduce, (46, 1), 1,
rhs_1'Access, null);
+ Add_Action (Table.States (49), 29, Reduce, (46, 1), 1,
rhs_1'Access, null);
+ Add_Action (Table.States (49), 33, 43);
+ Add_Conflict (Table.States (49), 33, (46, 1), 1, rhs_1'Access,
null);
+ Add_Action (Table.States (49), 35, 44);
+ Add_Action (Table.States (49), 36, Reduce, (46, 1), 1,
rhs_1'Access, null);
+ Table.States (49).Goto_List.Set_Capacity (6);
+ Add_Goto (Table.States (49), 47, 47);
+ Add_Goto (Table.States (49), 48, 114);
+ Add_Goto (Table.States (49), 50, 50);
+ Add_Goto (Table.States (49), 51, 51);
+ Add_Goto (Table.States (49), 52, 52);
+ Add_Goto (Table.States (49), 53, 53);
+ Table.States (49).Kernel := To_Vector (((46, 49, 0, False), (46,
49, 1, False), (46, 49, 2, False), (49,
+ 49, 1, True)));
+ Table.States (49).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 46, 1)));
+ Table.States (50).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (50), (11, 12, 18, 19, 20, 21, 23, 29,
33, 35, 36), (48, 0), 1, null, null);
+ Table.States (50).Kernel := To_Vector ((0 => (48, 50, 0, False)));
+ Table.States (50).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 48, 1)));
+ Table.States (51).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (51), (11, 12, 18, 19, 20, 21, 23, 29,
33, 35, 36), (50, 5), 1, null, null);
+ Table.States (51).Kernel := To_Vector ((0 => (50, 51, 0, False)));
+ Table.States (51).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (52).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (52), (11, 12, 18, 19, 20, 21, 23, 29,
33, 35, 36), (50, 3), 1, null, null);
+ Table.States (52).Kernel := To_Vector ((0 => (50, 52, 0, False)));
+ Table.States (52).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (53).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (53), (11, 12, 18, 19, 20, 21, 23, 29,
33, 35, 36), (50, 4), 1, null, null);
+ Table.States (53).Kernel := To_Vector ((0 => (50, 53, 0, False)));
+ Table.States (53).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (54).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (54), (23, 33, 36), (38, 1), 4,
declaration_1'Access, null);
+ Table.States (54).Kernel := To_Vector ((0 => (38, 9, 0, False)));
+ Table.States (54).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 38, 4)));
+ Table.States (55).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (55), (9, 33), (40, 1), 2, null, null);
+ Table.States (55).Kernel := To_Vector ((0 => (40, 33, 0, True)));
+ Table.States (55).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 40, 2)));
+ Table.States (55).Minimal_Complete_Actions_Recursive := True;
+ Table.States (56).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (56), 33, 115);
+ Table.States (56).Kernel := To_Vector ((0 => (38, 16, 1, False)));
+ Table.States (56).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 115)));
+ Table.States (57).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (57), 17, 116);
+ Table.States (57).Kernel := To_Vector ((0 => (39, 33, 1, False)));
+ Table.States (57).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 17, 116)));
+ Table.States (58).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (58), 17, 117);
+ Table.States (58).Kernel := To_Vector ((0 => (39, 33, 1, False)));
+ Table.States (58).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 17, 117)));
+ Table.States (59).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (59), (8, 10, 15, 16, 20, 23, 28, 30, 32,
33, 34, 35, 36), (41, 1), 2, null,
+ null);
+ Table.States (59).Kernel := To_Vector ((0 => (41, 42, 0, True)));
+ Table.States (59).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 41, 2)));
+ Table.States (59).Minimal_Complete_Actions_Recursive := True;
+ Table.States (60).Action_List.Set_Capacity (13);
+ Add_Action (Table.States (60), 8, 25);
+ Add_Action (Table.States (60), 10, 26);
+ Add_Action (Table.States (60), 15, 27);
+ Add_Action (Table.States (60), 16, 28);
+ Add_Action (Table.States (60), 20, 29);
+ Add_Action (Table.States (60), 23, Reduce, (38, 0), 4,
declaration_0'Access, null);
+ Add_Action (Table.States (60), 28, 30);
+ Add_Action (Table.States (60), 30, 31);
+ Add_Action (Table.States (60), 32, 32);
+ Add_Action (Table.States (60), 33, 33);
+ Add_Conflict (Table.States (60), 33, (38, 0), 4,
declaration_0'Access, null);
+ Add_Action (Table.States (60), 34, 34);
+ Add_Action (Table.States (60), 35, 35);
+ Add_Action (Table.States (60), 36, Reduce, (38, 0), 4,
declaration_0'Access, null);
+ Table.States (60).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (60), 42, 59);
+ Table.States (60).Kernel := To_Vector (((38, 41, 0, False), (41,
41, 1, True)));
+ Table.States (60).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 38, 4)));
+ Table.States (61).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (61), 18, 61);
+ Add_Action (Table.States (61), 19, 62);
+ Add_Action (Table.States (61), 20, 63);
+ Add_Action (Table.States (61), 21, 64);
+ Add_Action (Table.States (61), 33, 65);
+ Add_Action (Table.States (61), 35, 66);
+ Table.States (61).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (61), 47, 67);
+ Add_Goto (Table.States (61), 48, 68);
+ Add_Goto (Table.States (61), 49, 69);
+ Add_Goto (Table.States (61), 50, 70);
+ Add_Goto (Table.States (61), 51, 71);
+ Add_Goto (Table.States (61), 52, 72);
+ Add_Goto (Table.States (61), 53, 73);
+ Add_Goto (Table.States (61), 54, 118);
+ Table.States (61).Kernel := To_Vector (((53, 18, 2, False), (53,
18, 3, False)));
+ Table.States (61).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 65)));
+ Table.States (62).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (62), 18, 75);
+ Add_Action (Table.States (62), 19, 76);
+ Add_Action (Table.States (62), 20, 77);
+ Add_Action (Table.States (62), 21, 78);
+ Add_Action (Table.States (62), 33, 79);
+ Add_Action (Table.States (62), 35, 80);
+ Table.States (62).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (62), 47, 81);
+ Add_Goto (Table.States (62), 48, 82);
+ Add_Goto (Table.States (62), 49, 83);
+ Add_Goto (Table.States (62), 50, 84);
+ Add_Goto (Table.States (62), 51, 85);
+ Add_Goto (Table.States (62), 52, 86);
+ Add_Goto (Table.States (62), 53, 87);
+ Add_Goto (Table.States (62), 54, 119);
+ Table.States (62).Kernel := To_Vector ((0 => (52, 19, 2, False)));
+ Table.States (62).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 79)));
+ Table.States (63).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (63), 18, 89);
+ Add_Action (Table.States (63), 19, 90);
+ Add_Action (Table.States (63), 20, 91);
+ Add_Action (Table.States (63), 21, 92);
+ Add_Action (Table.States (63), 33, 93);
+ Add_Action (Table.States (63), 35, 94);
+ Table.States (63).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (63), 47, 95);
+ Add_Goto (Table.States (63), 48, 96);
+ Add_Goto (Table.States (63), 49, 97);
+ Add_Goto (Table.States (63), 50, 98);
+ Add_Goto (Table.States (63), 51, 99);
+ Add_Goto (Table.States (63), 52, 100);
+ Add_Goto (Table.States (63), 53, 101);
+ Add_Goto (Table.States (63), 54, 120);
+ Table.States (63).Kernel := To_Vector (((51, 20, 2, False), (52,
20, 3, False), (53, 20, 3, False), (53,
+ 20, 3, False)));
+ Table.States (63).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 93)));
+ Table.States (64).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (64), 33, 121);
+ Table.States (64).Kernel := To_Vector ((0 => (47, 21, 4, False)));
+ Table.States (64).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 121)));
+ Table.States (65).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (65), 12, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (65), 16, 122);
+ Add_Action (Table.States (65), 18, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (65), 19, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (65), 20, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (65), 21, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (65), 24, 123);
+ Add_Action (Table.States (65), 25, 124);
+ Add_Action (Table.States (65), 26, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (65), 31, 125);
+ Add_Action (Table.States (65), 33, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (65), 35, Reduce, (50, 0), 1, null, null);
+ Table.States (65).Kernel := To_Vector (((48, 33, 2, False), (50,
33, 0, False), (52, 33, 1, False), (53,
+ 33, 1, False), (53, 33, 1, False)));
+ Table.States (65).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (66).Action_List.Set_Capacity (9);
+ Add_Action (Table.States (66), 12, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (66), 18, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (66), 19, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (66), 20, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (66), 21, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (66), 25, 126);
+ Add_Action (Table.States (66), 26, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (66), 33, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (66), 35, Reduce, (50, 1), 1, null, null);
+ Table.States (66).Kernel := To_Vector (((50, 35, 0, False), (52,
35, 1, False)));
+ Table.States (66).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (67).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (67), (12, 18, 19, 20, 21, 26, 33, 35),
(50, 2), 1, null, null);
+ Table.States (67).Kernel := To_Vector ((0 => (50, 47, 0, False)));
+ Table.States (67).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (68).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (68), (12, 18, 19, 20, 21, 26, 33, 35),
(49, 0), 1, null, null);
+ Table.States (68).Kernel := To_Vector ((0 => (49, 48, 0, False)));
+ Table.States (68).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 49, 1)));
+ Table.States (69).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (69), 12, Reduce, (54, 0), 1, null, null);
+ Add_Action (Table.States (69), 18, 61);
+ Add_Action (Table.States (69), 19, 62);
+ Add_Action (Table.States (69), 20, 63);
+ Add_Action (Table.States (69), 21, 64);
+ Add_Action (Table.States (69), 26, Reduce, (54, 0), 1, null, null);
+ Add_Action (Table.States (69), 33, 65);
+ Add_Action (Table.States (69), 35, 66);
+ Table.States (69).Goto_List.Set_Capacity (6);
+ Add_Goto (Table.States (69), 47, 67);
+ Add_Goto (Table.States (69), 48, 127);
+ Add_Goto (Table.States (69), 50, 70);
+ Add_Goto (Table.States (69), 51, 71);
+ Add_Goto (Table.States (69), 52, 72);
+ Add_Goto (Table.States (69), 53, 73);
+ Table.States (69).Kernel := To_Vector (((49, 49, 1, True), (54,
49, 0, False)));
+ Table.States (69).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 54, 1)));
+ Table.States (70).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (70), (12, 18, 19, 20, 21, 26, 33, 35),
(48, 0), 1, null, null);
+ Table.States (70).Kernel := To_Vector ((0 => (48, 50, 0, False)));
+ Table.States (70).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 48, 1)));
+ Table.States (71).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (71), (12, 18, 19, 20, 21, 26, 33, 35),
(50, 5), 1, null, null);
+ Table.States (71).Kernel := To_Vector ((0 => (50, 51, 0, False)));
+ Table.States (71).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (72).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (72), (12, 18, 19, 20, 21, 26, 33, 35),
(50, 3), 1, null, null);
+ Table.States (72).Kernel := To_Vector ((0 => (50, 52, 0, False)));
+ Table.States (72).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (73).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (73), (12, 18, 19, 20, 21, 26, 33, 35),
(50, 4), 1, null, null);
+ Table.States (73).Kernel := To_Vector ((0 => (50, 53, 0, False)));
+ Table.States (73).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (74).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (74), 12, 128);
+ Add_Action (Table.States (74), 26, 129);
+ Table.States (74).Kernel := To_Vector (((53, 54, 1, False), (53,
54, 2, False), (54, 54, 2, True)));
+ Table.States (74).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 26, 129)));
+ Table.States (75).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (75), 18, 61);
+ Add_Action (Table.States (75), 19, 62);
+ Add_Action (Table.States (75), 20, 63);
+ Add_Action (Table.States (75), 21, 64);
+ Add_Action (Table.States (75), 33, 65);
+ Add_Action (Table.States (75), 35, 66);
+ Table.States (75).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (75), 47, 67);
+ Add_Goto (Table.States (75), 48, 68);
+ Add_Goto (Table.States (75), 49, 69);
+ Add_Goto (Table.States (75), 50, 70);
+ Add_Goto (Table.States (75), 51, 71);
+ Add_Goto (Table.States (75), 52, 72);
+ Add_Goto (Table.States (75), 53, 73);
+ Add_Goto (Table.States (75), 54, 130);
+ Table.States (75).Kernel := To_Vector (((53, 18, 2, False), (53,
18, 3, False)));
+ Table.States (75).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 65)));
+ Table.States (76).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (76), 18, 75);
+ Add_Action (Table.States (76), 19, 76);
+ Add_Action (Table.States (76), 20, 77);
+ Add_Action (Table.States (76), 21, 78);
+ Add_Action (Table.States (76), 33, 79);
+ Add_Action (Table.States (76), 35, 80);
+ Table.States (76).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (76), 47, 81);
+ Add_Goto (Table.States (76), 48, 82);
+ Add_Goto (Table.States (76), 49, 83);
+ Add_Goto (Table.States (76), 50, 84);
+ Add_Goto (Table.States (76), 51, 85);
+ Add_Goto (Table.States (76), 52, 86);
+ Add_Goto (Table.States (76), 53, 87);
+ Add_Goto (Table.States (76), 54, 131);
+ Table.States (76).Kernel := To_Vector ((0 => (52, 19, 2, False)));
+ Table.States (76).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 79)));
+ Table.States (77).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (77), 18, 89);
+ Add_Action (Table.States (77), 19, 90);
+ Add_Action (Table.States (77), 20, 91);
+ Add_Action (Table.States (77), 21, 92);
+ Add_Action (Table.States (77), 33, 93);
+ Add_Action (Table.States (77), 35, 94);
+ Table.States (77).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (77), 47, 95);
+ Add_Goto (Table.States (77), 48, 96);
+ Add_Goto (Table.States (77), 49, 97);
+ Add_Goto (Table.States (77), 50, 98);
+ Add_Goto (Table.States (77), 51, 99);
+ Add_Goto (Table.States (77), 52, 100);
+ Add_Goto (Table.States (77), 53, 101);
+ Add_Goto (Table.States (77), 54, 132);
+ Table.States (77).Kernel := To_Vector (((51, 20, 2, False), (52,
20, 3, False), (53, 20, 3, False), (53,
+ 20, 3, False)));
+ Table.States (77).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 93)));
+ Table.States (78).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (78), 33, 133);
+ Table.States (78).Kernel := To_Vector ((0 => (47, 21, 4, False)));
+ Table.States (78).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 133)));
+ Table.States (79).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (79), 12, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (79), 16, 134);
+ Add_Action (Table.States (79), 18, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (79), 19, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (79), 20, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (79), 21, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (79), 24, 135);
+ Add_Action (Table.States (79), 25, 136);
+ Add_Action (Table.States (79), 27, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (79), 31, 137);
+ Add_Action (Table.States (79), 33, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (79), 35, Reduce, (50, 0), 1, null, null);
+ Table.States (79).Kernel := To_Vector (((48, 33, 2, False), (50,
33, 0, False), (52, 33, 1, False), (53,
+ 33, 1, False), (53, 33, 1, False)));
+ Table.States (79).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (80).Action_List.Set_Capacity (9);
+ Add_Action (Table.States (80), 12, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (80), 18, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (80), 19, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (80), 20, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (80), 21, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (80), 25, 138);
+ Add_Action (Table.States (80), 27, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (80), 33, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (80), 35, Reduce, (50, 1), 1, null, null);
+ Table.States (80).Kernel := To_Vector (((50, 35, 0, False), (52,
35, 1, False)));
+ Table.States (80).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (81).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (81), (12, 18, 19, 20, 21, 27, 33, 35),
(50, 2), 1, null, null);
+ Table.States (81).Kernel := To_Vector ((0 => (50, 47, 0, False)));
+ Table.States (81).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (82).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (82), (12, 18, 19, 20, 21, 27, 33, 35),
(49, 0), 1, null, null);
+ Table.States (82).Kernel := To_Vector ((0 => (49, 48, 0, False)));
+ Table.States (82).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 49, 1)));
+ Table.States (83).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (83), 12, Reduce, (54, 0), 1, null, null);
+ Add_Action (Table.States (83), 18, 75);
+ Add_Action (Table.States (83), 19, 76);
+ Add_Action (Table.States (83), 20, 77);
+ Add_Action (Table.States (83), 21, 78);
+ Add_Action (Table.States (83), 27, Reduce, (54, 0), 1, null, null);
+ Add_Action (Table.States (83), 33, 79);
+ Add_Action (Table.States (83), 35, 80);
+ Table.States (83).Goto_List.Set_Capacity (6);
+ Add_Goto (Table.States (83), 47, 81);
+ Add_Goto (Table.States (83), 48, 139);
+ Add_Goto (Table.States (83), 50, 84);
+ Add_Goto (Table.States (83), 51, 85);
+ Add_Goto (Table.States (83), 52, 86);
+ Add_Goto (Table.States (83), 53, 87);
+ Table.States (83).Kernel := To_Vector (((49, 49, 1, True), (54,
49, 0, False)));
+ Table.States (83).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 54, 1)));
+ Table.States (84).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (84), (12, 18, 19, 20, 21, 27, 33, 35),
(48, 0), 1, null, null);
+ Table.States (84).Kernel := To_Vector ((0 => (48, 50, 0, False)));
+ Table.States (84).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 48, 1)));
+ end Subr_1;
+ procedure Subr_2
+ is begin
+ Table.States (85).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (85), (12, 18, 19, 20, 21, 27, 33, 35),
(50, 5), 1, null, null);
+ Table.States (85).Kernel := To_Vector ((0 => (50, 51, 0, False)));
+ Table.States (85).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (86).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (86), (12, 18, 19, 20, 21, 27, 33, 35),
(50, 3), 1, null, null);
+ Table.States (86).Kernel := To_Vector ((0 => (50, 52, 0, False)));
+ Table.States (86).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (87).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (87), (12, 18, 19, 20, 21, 27, 33, 35),
(50, 4), 1, null, null);
+ Table.States (87).Kernel := To_Vector ((0 => (50, 53, 0, False)));
+ Table.States (87).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (88).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (88), 12, 140);
+ Add_Action (Table.States (88), 27, 141);
+ Table.States (88).Kernel := To_Vector (((52, 54, 1, False), (54,
54, 2, True)));
+ Table.States (88).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 27, 141)));
+ Table.States (89).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (89), 18, 61);
+ Add_Action (Table.States (89), 19, 62);
+ Add_Action (Table.States (89), 20, 63);
+ Add_Action (Table.States (89), 21, 64);
+ Add_Action (Table.States (89), 33, 65);
+ Add_Action (Table.States (89), 35, 66);
+ Table.States (89).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (89), 47, 67);
+ Add_Goto (Table.States (89), 48, 68);
+ Add_Goto (Table.States (89), 49, 69);
+ Add_Goto (Table.States (89), 50, 70);
+ Add_Goto (Table.States (89), 51, 71);
+ Add_Goto (Table.States (89), 52, 72);
+ Add_Goto (Table.States (89), 53, 73);
+ Add_Goto (Table.States (89), 54, 142);
+ Table.States (89).Kernel := To_Vector (((53, 18, 2, False), (53,
18, 3, False)));
+ Table.States (89).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 65)));
+ Table.States (90).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (90), 18, 75);
+ Add_Action (Table.States (90), 19, 76);
+ Add_Action (Table.States (90), 20, 77);
+ Add_Action (Table.States (90), 21, 78);
+ Add_Action (Table.States (90), 33, 79);
+ Add_Action (Table.States (90), 35, 80);
+ Table.States (90).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (90), 47, 81);
+ Add_Goto (Table.States (90), 48, 82);
+ Add_Goto (Table.States (90), 49, 83);
+ Add_Goto (Table.States (90), 50, 84);
+ Add_Goto (Table.States (90), 51, 85);
+ Add_Goto (Table.States (90), 52, 86);
+ Add_Goto (Table.States (90), 53, 87);
+ Add_Goto (Table.States (90), 54, 143);
+ Table.States (90).Kernel := To_Vector ((0 => (52, 19, 2, False)));
+ Table.States (90).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 79)));
+ Table.States (91).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (91), 18, 89);
+ Add_Action (Table.States (91), 19, 90);
+ Add_Action (Table.States (91), 20, 91);
+ Add_Action (Table.States (91), 21, 92);
+ Add_Action (Table.States (91), 33, 93);
+ Add_Action (Table.States (91), 35, 94);
+ Table.States (91).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (91), 47, 95);
+ Add_Goto (Table.States (91), 48, 96);
+ Add_Goto (Table.States (91), 49, 97);
+ Add_Goto (Table.States (91), 50, 98);
+ Add_Goto (Table.States (91), 51, 99);
+ Add_Goto (Table.States (91), 52, 100);
+ Add_Goto (Table.States (91), 53, 101);
+ Add_Goto (Table.States (91), 54, 144);
+ Table.States (91).Kernel := To_Vector (((51, 20, 2, False), (52,
20, 3, False), (53, 20, 3, False), (53,
+ 20, 3, False)));
+ Table.States (91).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 93)));
+ Table.States (92).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (92), 33, 145);
+ Table.States (92).Kernel := To_Vector ((0 => (47, 21, 4, False)));
+ Table.States (92).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 145)));
+ Table.States (93).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (93), 12, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (93), 16, 146);
+ Add_Action (Table.States (93), 18, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (93), 19, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (93), 20, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (93), 21, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (93), 24, 147);
+ Add_Action (Table.States (93), 25, 148);
+ Add_Action (Table.States (93), 28, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (93), 31, 149);
+ Add_Action (Table.States (93), 33, Reduce, (50, 0), 1, null, null);
+ Add_Action (Table.States (93), 35, Reduce, (50, 0), 1, null, null);
+ Table.States (93).Kernel := To_Vector (((48, 33, 2, False), (50,
33, 0, False), (52, 33, 1, False), (53,
+ 33, 1, False), (53, 33, 1, False)));
+ Table.States (93).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (94).Action_List.Set_Capacity (9);
+ Add_Action (Table.States (94), 12, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (94), 18, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (94), 19, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (94), 20, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (94), 21, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (94), 25, 150);
+ Add_Action (Table.States (94), 28, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (94), 33, Reduce, (50, 1), 1, null, null);
+ Add_Action (Table.States (94), 35, Reduce, (50, 1), 1, null, null);
+ Table.States (94).Kernel := To_Vector (((50, 35, 0, False), (52,
35, 1, False)));
+ Table.States (94).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (95).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (95), (12, 18, 19, 20, 21, 28, 33, 35),
(50, 2), 1, null, null);
+ Table.States (95).Kernel := To_Vector ((0 => (50, 47, 0, False)));
+ Table.States (95).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (96).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (96), (12, 18, 19, 20, 21, 28, 33, 35),
(49, 0), 1, null, null);
+ Table.States (96).Kernel := To_Vector ((0 => (49, 48, 0, False)));
+ Table.States (96).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 49, 1)));
+ Table.States (97).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (97), 12, Reduce, (54, 0), 1, null, null);
+ Add_Action (Table.States (97), 18, 89);
+ Add_Action (Table.States (97), 19, 90);
+ Add_Action (Table.States (97), 20, 91);
+ Add_Action (Table.States (97), 21, 92);
+ Add_Action (Table.States (97), 28, Reduce, (54, 0), 1, null, null);
+ Add_Action (Table.States (97), 33, 93);
+ Add_Action (Table.States (97), 35, 94);
+ Table.States (97).Goto_List.Set_Capacity (6);
+ Add_Goto (Table.States (97), 47, 95);
+ Add_Goto (Table.States (97), 48, 151);
+ Add_Goto (Table.States (97), 50, 98);
+ Add_Goto (Table.States (97), 51, 99);
+ Add_Goto (Table.States (97), 52, 100);
+ Add_Goto (Table.States (97), 53, 101);
+ Table.States (97).Kernel := To_Vector (((49, 49, 1, True), (54,
49, 0, False)));
+ Table.States (97).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 54, 1)));
+ Table.States (98).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (98), (12, 18, 19, 20, 21, 28, 33, 35),
(48, 0), 1, null, null);
+ Table.States (98).Kernel := To_Vector ((0 => (48, 50, 0, False)));
+ Table.States (98).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 48, 1)));
+ Table.States (99).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (99), (12, 18, 19, 20, 21, 28, 33, 35),
(50, 5), 1, null, null);
+ Table.States (99).Kernel := To_Vector ((0 => (50, 51, 0, False)));
+ Table.States (99).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (100).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (100), (12, 18, 19, 20, 21, 28, 33, 35),
(50, 3), 1, null, null);
+ Table.States (100).Kernel := To_Vector ((0 => (50, 52, 0, False)));
+ Table.States (100).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (101).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (101), (12, 18, 19, 20, 21, 28, 33, 35),
(50, 4), 1, null, null);
+ Table.States (101).Kernel := To_Vector ((0 => (50, 53, 0, False)));
+ Table.States (101).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (102).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (102), 12, 152);
+ Add_Action (Table.States (102), 28, 153);
+ Table.States (102).Kernel := To_Vector (((51, 54, 1, False), (52,
54, 2, False), (53, 54, 2, False), (53,
+ 54, 2, False), (54, 54, 2, True)));
+ Table.States (102).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 28, 153)));
+ Table.States (103).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (103), 16, 154);
+ Table.States (103).Kernel := To_Vector ((0 => (47, 33, 3, False)));
+ Table.States (103).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 16, 154)));
+ Table.States (104).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (104), 18, 39);
+ Add_Action (Table.States (104), 19, 40);
+ Add_Action (Table.States (104), 20, 41);
+ Add_Action (Table.States (104), 21, 42);
+ Add_Action (Table.States (104), 33, 155);
+ Add_Action (Table.States (104), 35, 44);
+ Table.States (104).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (104), 47, 47);
+ Add_Goto (Table.States (104), 50, 156);
+ Add_Goto (Table.States (104), 51, 51);
+ Add_Goto (Table.States (104), 52, 52);
+ Add_Goto (Table.States (104), 53, 53);
+ Table.States (104).Kernel := To_Vector ((0 => (48, 16, 1, False)));
+ Table.States (104).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 155)));
+ Table.States (105).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (105), (11, 12, 18, 19, 20, 21, 23, 29,
33, 35, 36), (53, 4), 2, null, null);
+ Table.States (105).Kernel := To_Vector ((0 => (53, 24, 0, False)));
+ Table.States (105).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 53, 2)));
+ Table.States (106).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (106), (11, 12, 18, 19, 20, 21, 23, 29,
33, 35, 36), (52, 2), 2, null, null);
+ Table.States (106).Kernel := To_Vector ((0 => (52, 25, 0, False)));
+ Table.States (106).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 52, 2)));
+ Table.States (107).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (107), (11, 12, 18, 19, 20, 21, 23, 29,
33, 35, 36), (53, 5), 2, null, null);
+ Table.States (107).Kernel := To_Vector ((0 => (53, 31, 0, False)));
+ Table.States (107).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 53, 2)));
+ Table.States (108).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (108), (11, 12, 18, 19, 20, 21, 23, 29,
33, 35, 36), (52, 3), 2, null, null);
+ Table.States (108).Kernel := To_Vector ((0 => (52, 25, 0, False)));
+ Table.States (108).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 52, 2)));
+ Table.States (109).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (109), 12, Reduce, (46, 0), 0, null,
null);
+ Add_Action (Table.States (109), 18, 39);
+ Add_Action (Table.States (109), 19, 40);
+ Add_Action (Table.States (109), 20, 41);
+ Add_Action (Table.States (109), 21, 42);
+ Add_Action (Table.States (109), 23, Reduce, (46, 0), 0, null,
null);
+ Add_Action (Table.States (109), 29, Reduce, (46, 0), 0, null,
null);
+ Add_Action (Table.States (109), 33, 43);
+ Add_Conflict (Table.States (109), 33, (46, 0), 0, null, null);
+ Add_Action (Table.States (109), 35, 44);
+ Add_Action (Table.States (109), 36, Reduce, (46, 0), 0, null,
null);
+ Table.States (109).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (109), 46, 157);
+ Add_Goto (Table.States (109), 47, 47);
+ Add_Goto (Table.States (109), 48, 48);
+ Add_Goto (Table.States (109), 49, 49);
+ Add_Goto (Table.States (109), 50, 50);
+ Add_Goto (Table.States (109), 51, 51);
+ Add_Goto (Table.States (109), 52, 52);
+ Add_Goto (Table.States (109), 53, 53);
+ Table.States (109).Kernel := To_Vector ((0 => (45, 12, 0, True)));
+ Table.States (109).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 46, 0)));
+ Table.States (109).Minimal_Complete_Actions_Recursive := True;
+ Table.States (110).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (110), 4, 158);
+ Add_Action (Table.States (110), 5, 159);
+ Table.States (110).Kernel := To_Vector (((45, 23, 4, True), (45,
23, 2, True)));
+ Table.States (110).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 4, 158)));
+ Table.States (110).Minimal_Complete_Actions_Recursive := True;
+ Table.States (111).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (111), (23, 33, 36), (44, 0), 1, null,
null);
+ Table.States (111).Kernel := To_Vector ((0 => (44, 29, 0, False)));
+ Table.States (111).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 44, 1)));
+ Table.States (112).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (112), (23, 33, 36), (43, 0), 4,
nonterminal_0'Access, null);
+ Table.States (112).Kernel := To_Vector ((0 => (43, 44, 0, False)));
+ Table.States (112).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 43, 4)));
+ Table.States (113).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (113), 11, 160);
+ Add_Action (Table.States (113), 12, Reduce, (46, 2), 2,
rhs_2'Access, null);
+ Add_Action (Table.States (113), 23, Reduce, (46, 2), 2,
rhs_2'Access, null);
+ Add_Action (Table.States (113), 29, Reduce, (46, 2), 2,
rhs_2'Access, null);
+ Add_Action (Table.States (113), 33, Reduce, (46, 2), 2,
rhs_2'Access, null);
+ Add_Action (Table.States (113), 36, Reduce, (46, 2), 2,
rhs_2'Access, null);
+ Table.States (113).Kernel := To_Vector (((46, 11, 0, False), (46,
11, 1, False)));
+ Table.States (113).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 46, 2)));
+ Table.States (114).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (114), (11, 12, 18, 19, 20, 21, 23, 29,
33, 35, 36), (49, 1), 2, null, null);
+ Table.States (114).Kernel := To_Vector ((0 => (49, 48, 0, True)));
+ Table.States (114).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 49, 2)));
+ Table.States (114).Minimal_Complete_Actions_Recursive := True;
+ Table.States (115).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (115), (23, 33, 36), (38, 4), 5,
declaration_4'Access, null);
+ Table.States (115).Kernel := To_Vector ((0 => (38, 33, 0, False)));
+ Table.States (115).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 38, 5)));
+ Table.States (116).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (116), (1 => 33), (39, 1), 4,
token_keyword_non_grammar_1'Access, null);
+ Table.States (116).Kernel := To_Vector ((0 => (39, 17, 0, False)));
+ Table.States (116).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 39, 4)));
+ Table.States (117).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (117), (1 => 33), (39, 2), 4,
token_keyword_non_grammar_2'Access, null);
+ Table.States (117).Kernel := To_Vector ((0 => (39, 17, 0, False)));
+ Table.States (117).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 39, 4)));
+ Table.States (118).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (118), 12, 128);
+ Add_Action (Table.States (118), 26, 161);
+ Table.States (118).Kernel := To_Vector (((53, 54, 1, False), (53,
54, 2, False), (54, 54, 2, True)));
+ Table.States (118).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 26, 161)));
+ Table.States (119).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (119), 12, 140);
+ Add_Action (Table.States (119), 27, 162);
+ Table.States (119).Kernel := To_Vector (((52, 54, 1, False), (54,
54, 2, True)));
+ Table.States (119).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 27, 162)));
+ Table.States (120).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (120), 12, 152);
+ Add_Action (Table.States (120), 28, 163);
+ Table.States (120).Kernel := To_Vector (((51, 54, 1, False), (52,
54, 2, False), (53, 54, 2, False), (53,
+ 54, 2, False), (54, 54, 2, True)));
+ Table.States (120).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 28, 163)));
+ Table.States (121).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (121), 16, 164);
+ Table.States (121).Kernel := To_Vector ((0 => (47, 33, 3, False)));
+ Table.States (121).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 16, 164)));
+ Table.States (122).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (122), 18, 61);
+ Add_Action (Table.States (122), 19, 62);
+ Add_Action (Table.States (122), 20, 63);
+ Add_Action (Table.States (122), 21, 64);
+ Add_Action (Table.States (122), 33, 165);
+ Add_Action (Table.States (122), 35, 66);
+ Table.States (122).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (122), 47, 67);
+ Add_Goto (Table.States (122), 50, 166);
+ Add_Goto (Table.States (122), 51, 71);
+ Add_Goto (Table.States (122), 52, 72);
+ Add_Goto (Table.States (122), 53, 73);
+ Table.States (122).Kernel := To_Vector ((0 => (48, 16, 1, False)));
+ Table.States (122).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 165)));
+ Table.States (123).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (123), (12, 18, 19, 20, 21, 26, 33, 35),
(53, 4), 2, null, null);
+ Table.States (123).Kernel := To_Vector ((0 => (53, 24, 0, False)));
+ Table.States (123).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 53, 2)));
+ Table.States (124).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (124), (12, 18, 19, 20, 21, 26, 33, 35),
(52, 2), 2, null, null);
+ Table.States (124).Kernel := To_Vector ((0 => (52, 25, 0, False)));
+ Table.States (124).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 52, 2)));
+ Table.States (125).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (125), (12, 18, 19, 20, 21, 26, 33, 35),
(53, 5), 2, null, null);
+ Table.States (125).Kernel := To_Vector ((0 => (53, 31, 0, False)));
+ Table.States (125).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 53, 2)));
+ Table.States (126).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (126), (12, 18, 19, 20, 21, 26, 33, 35),
(52, 3), 2, null, null);
+ Table.States (126).Kernel := To_Vector ((0 => (52, 25, 0, False)));
+ Table.States (126).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 52, 2)));
+ Table.States (127).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (127), (12, 18, 19, 20, 21, 26, 33, 35),
(49, 1), 2, null, null);
+ Table.States (127).Kernel := To_Vector ((0 => (49, 48, 0, True)));
+ Table.States (127).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 49, 2)));
+ Table.States (127).Minimal_Complete_Actions_Recursive := True;
+ Table.States (128).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (128), 18, 61);
+ Add_Action (Table.States (128), 19, 62);
+ Add_Action (Table.States (128), 20, 63);
+ Add_Action (Table.States (128), 21, 64);
+ Add_Action (Table.States (128), 33, 65);
+ Add_Action (Table.States (128), 35, 66);
+ Table.States (128).Goto_List.Set_Capacity (7);
+ Add_Goto (Table.States (128), 47, 67);
+ Add_Goto (Table.States (128), 48, 68);
+ Add_Goto (Table.States (128), 49, 167);
+ Add_Goto (Table.States (128), 50, 70);
+ Add_Goto (Table.States (128), 51, 71);
+ Add_Goto (Table.States (128), 52, 72);
+ Add_Goto (Table.States (128), 53, 73);
+ Table.States (128).Kernel := To_Vector ((0 => (54, 12, 1, True)));
+ Table.States (128).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 65)));
+ Table.States (128).Minimal_Complete_Actions_Recursive := True;
+ Table.States (129).Action_List.Set_Capacity (12);
+ Add_Action (Table.States (129), 11, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (129), 12, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (129), 18, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (129), 19, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (129), 20, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (129), 21, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (129), 22, 168);
+ Add_Action (Table.States (129), 23, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (129), 29, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (129), 33, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (129), 35, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (129), 36, Reduce, (53, 0), 3, null,
null);
+ Table.States (129).Kernel := To_Vector (((53, 26, 0, False), (53,
26, 1, False)));
+ Table.States (129).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 53, 3)));
+ Table.States (130).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (130), 12, 128);
+ Add_Action (Table.States (130), 26, 169);
+ Table.States (130).Kernel := To_Vector (((53, 54, 1, False), (53,
54, 2, False), (54, 54, 2, True)));
+ Table.States (130).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 26, 169)));
+ Table.States (131).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (131), 12, 140);
+ Add_Action (Table.States (131), 27, 170);
+ Table.States (131).Kernel := To_Vector (((52, 54, 1, False), (54,
54, 2, True)));
+ Table.States (131).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 27, 170)));
+ Table.States (132).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (132), 12, 152);
+ Add_Action (Table.States (132), 28, 171);
+ Table.States (132).Kernel := To_Vector (((51, 54, 1, False), (52,
54, 2, False), (53, 54, 2, False), (53,
+ 54, 2, False), (54, 54, 2, True)));
+ Table.States (132).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 28, 171)));
+ Table.States (133).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (133), 16, 172);
+ Table.States (133).Kernel := To_Vector ((0 => (47, 33, 3, False)));
+ Table.States (133).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 16, 172)));
+ Table.States (134).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (134), 18, 75);
+ Add_Action (Table.States (134), 19, 76);
+ Add_Action (Table.States (134), 20, 77);
+ Add_Action (Table.States (134), 21, 78);
+ Add_Action (Table.States (134), 33, 173);
+ Add_Action (Table.States (134), 35, 80);
+ Table.States (134).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (134), 47, 81);
+ Add_Goto (Table.States (134), 50, 174);
+ Add_Goto (Table.States (134), 51, 85);
+ Add_Goto (Table.States (134), 52, 86);
+ Add_Goto (Table.States (134), 53, 87);
+ Table.States (134).Kernel := To_Vector ((0 => (48, 16, 1, False)));
+ Table.States (134).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 173)));
+ Table.States (135).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (135), (12, 18, 19, 20, 21, 27, 33, 35),
(53, 4), 2, null, null);
+ Table.States (135).Kernel := To_Vector ((0 => (53, 24, 0, False)));
+ Table.States (135).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 53, 2)));
+ Table.States (136).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (136), (12, 18, 19, 20, 21, 27, 33, 35),
(52, 2), 2, null, null);
+ Table.States (136).Kernel := To_Vector ((0 => (52, 25, 0, False)));
+ Table.States (136).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 52, 2)));
+ Table.States (137).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (137), (12, 18, 19, 20, 21, 27, 33, 35),
(53, 5), 2, null, null);
+ Table.States (137).Kernel := To_Vector ((0 => (53, 31, 0, False)));
+ Table.States (137).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 53, 2)));
+ Table.States (138).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (138), (12, 18, 19, 20, 21, 27, 33, 35),
(52, 3), 2, null, null);
+ Table.States (138).Kernel := To_Vector ((0 => (52, 25, 0, False)));
+ Table.States (138).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 52, 2)));
+ Table.States (139).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (139), (12, 18, 19, 20, 21, 27, 33, 35),
(49, 1), 2, null, null);
+ Table.States (139).Kernel := To_Vector ((0 => (49, 48, 0, True)));
+ Table.States (139).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 49, 2)));
+ Table.States (139).Minimal_Complete_Actions_Recursive := True;
+ Table.States (140).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (140), 18, 75);
+ Add_Action (Table.States (140), 19, 76);
+ Add_Action (Table.States (140), 20, 77);
+ Add_Action (Table.States (140), 21, 78);
+ Add_Action (Table.States (140), 33, 79);
+ Add_Action (Table.States (140), 35, 80);
+ Table.States (140).Goto_List.Set_Capacity (7);
+ Add_Goto (Table.States (140), 47, 81);
+ Add_Goto (Table.States (140), 48, 82);
+ Add_Goto (Table.States (140), 49, 175);
+ Add_Goto (Table.States (140), 50, 84);
+ Add_Goto (Table.States (140), 51, 85);
+ Add_Goto (Table.States (140), 52, 86);
+ Add_Goto (Table.States (140), 53, 87);
+ Table.States (140).Kernel := To_Vector ((0 => (54, 12, 1, True)));
+ Table.States (140).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 79)));
+ Table.States (140).Minimal_Complete_Actions_Recursive := True;
+ Table.States (141).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (141), (11, 12, 18, 19, 20, 21, 23, 29,
33, 35, 36), (52, 0), 3, null, null);
+ Table.States (141).Kernel := To_Vector ((0 => (52, 27, 0, False)));
+ Table.States (141).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 52, 3)));
+ Table.States (142).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (142), 12, 128);
+ Add_Action (Table.States (142), 26, 176);
+ Table.States (142).Kernel := To_Vector (((53, 54, 1, False), (53,
54, 2, False), (54, 54, 2, True)));
+ Table.States (142).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 26, 176)));
+ Table.States (143).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (143), 12, 140);
+ Add_Action (Table.States (143), 27, 177);
+ Table.States (143).Kernel := To_Vector (((52, 54, 1, False), (54,
54, 2, True)));
+ Table.States (143).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 27, 177)));
+ Table.States (144).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (144), 12, 152);
+ Add_Action (Table.States (144), 28, 178);
+ Table.States (144).Kernel := To_Vector (((51, 54, 1, False), (52,
54, 2, False), (53, 54, 2, False), (53,
+ 54, 2, False), (54, 54, 2, True)));
+ Table.States (144).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 28, 178)));
+ Table.States (145).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (145), 16, 179);
+ Table.States (145).Kernel := To_Vector ((0 => (47, 33, 3, False)));
+ Table.States (145).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 16, 179)));
+ Table.States (146).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (146), 18, 89);
+ Add_Action (Table.States (146), 19, 90);
+ Add_Action (Table.States (146), 20, 91);
+ Add_Action (Table.States (146), 21, 92);
+ Add_Action (Table.States (146), 33, 180);
+ Add_Action (Table.States (146), 35, 94);
+ Table.States (146).Goto_List.Set_Capacity (5);
+ Add_Goto (Table.States (146), 47, 95);
+ Add_Goto (Table.States (146), 50, 181);
+ Add_Goto (Table.States (146), 51, 99);
+ Add_Goto (Table.States (146), 52, 100);
+ Add_Goto (Table.States (146), 53, 101);
+ Table.States (146).Kernel := To_Vector ((0 => (48, 16, 1, False)));
+ Table.States (146).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 180)));
+ Table.States (147).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (147), (12, 18, 19, 20, 21, 28, 33, 35),
(53, 4), 2, null, null);
+ Table.States (147).Kernel := To_Vector ((0 => (53, 24, 0, False)));
+ Table.States (147).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 53, 2)));
+ Table.States (148).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (148), (12, 18, 19, 20, 21, 28, 33, 35),
(52, 2), 2, null, null);
+ Table.States (148).Kernel := To_Vector ((0 => (52, 25, 0, False)));
+ Table.States (148).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 52, 2)));
+ Table.States (149).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (149), (12, 18, 19, 20, 21, 28, 33, 35),
(53, 5), 2, null, null);
+ Table.States (149).Kernel := To_Vector ((0 => (53, 31, 0, False)));
+ Table.States (149).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 53, 2)));
+ Table.States (150).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (150), (12, 18, 19, 20, 21, 28, 33, 35),
(52, 3), 2, null, null);
+ Table.States (150).Kernel := To_Vector ((0 => (52, 25, 0, False)));
+ Table.States (150).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 52, 2)));
+ Table.States (151).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (151), (12, 18, 19, 20, 21, 28, 33, 35),
(49, 1), 2, null, null);
+ Table.States (151).Kernel := To_Vector ((0 => (49, 48, 0, True)));
+ Table.States (151).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 49, 2)));
+ Table.States (151).Minimal_Complete_Actions_Recursive := True;
+ Table.States (152).Action_List.Set_Capacity (6);
+ Add_Action (Table.States (152), 18, 89);
+ Add_Action (Table.States (152), 19, 90);
+ Add_Action (Table.States (152), 20, 91);
+ Add_Action (Table.States (152), 21, 92);
+ Add_Action (Table.States (152), 33, 93);
+ Add_Action (Table.States (152), 35, 94);
+ Table.States (152).Goto_List.Set_Capacity (7);
+ Add_Goto (Table.States (152), 47, 95);
+ Add_Goto (Table.States (152), 48, 96);
+ Add_Goto (Table.States (152), 49, 182);
+ Add_Goto (Table.States (152), 50, 98);
+ Add_Goto (Table.States (152), 51, 99);
+ Add_Goto (Table.States (152), 52, 100);
+ Add_Goto (Table.States (152), 53, 101);
+ Table.States (152).Kernel := To_Vector ((0 => (54, 12, 1, True)));
+ Table.States (152).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 93)));
+ Table.States (152).Minimal_Complete_Actions_Recursive := True;
+ Table.States (153).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (153), 11, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (153), 12, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (153), 18, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (153), 19, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (153), 20, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (153), 21, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (153), 23, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (153), 24, 183);
+ Add_Action (Table.States (153), 25, 184);
+ Add_Action (Table.States (153), 29, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (153), 31, 185);
+ Add_Action (Table.States (153), 33, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (153), 35, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (153), 36, Reduce, (51, 0), 3, null,
null);
+ Table.States (153).Kernel := To_Vector (((51, 28, 0, False), (52,
28, 1, False), (53, 28, 1, False), (53,
+ 28, 1, False)));
+ Table.States (153).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 51, 3)));
+ Table.States (154).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (154), 33, 186);
+ Table.States (154).Kernel := To_Vector ((0 => (47, 16, 2, False)));
+ Table.States (154).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 186)));
+ Table.States (155).Action_List.Set_Capacity (14);
+ Add_Action (Table.States (155), 11, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (155), 12, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (155), 18, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (155), 19, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (155), 20, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (155), 21, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (155), 23, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (155), 24, 105);
+ Add_Action (Table.States (155), 25, 106);
+ Add_Action (Table.States (155), 29, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (155), 31, 107);
+ Add_Action (Table.States (155), 33, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (155), 35, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (155), 36, Reduce, (50, 0), 1, null,
null);
+ Table.States (155).Kernel := To_Vector (((50, 33, 0, False), (52,
33, 1, False), (53, 33, 1, False), (53,
+ 33, 1, False)));
+ Table.States (155).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (156).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (156), (11, 12, 18, 19, 20, 21, 23, 29,
33, 35, 36), (48, 1), 3, null, null);
+ Table.States (156).Kernel := To_Vector ((0 => (48, 50, 0, False)));
+ Table.States (156).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 48, 3)));
+ Table.States (157).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (157), (12, 23, 29, 33, 36), (45, 1), 3,
rhs_list_1'Access, null);
+ Table.States (157).Kernel := To_Vector ((0 => (45, 46, 0, True)));
+ Table.States (157).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 45, 3)));
+ Table.States (157).Minimal_Complete_Actions_Recursive := True;
+ Table.States (158).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (158), 5, 187);
+ Table.States (158).Kernel := To_Vector ((0 => (45, 4, 1, True)));
+ Table.States (158).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 5, 187)));
+ Table.States (158).Minimal_Complete_Actions_Recursive := True;
+ Table.States (159).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (159), 33, 188);
+ Table.States (159).Kernel := To_Vector ((0 => (45, 5, 3, True)));
+ Table.States (159).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 188)));
+ Table.States (159).Minimal_Complete_Actions_Recursive := True;
+ Table.States (160).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (160), (12, 23, 29, 33, 36), (46, 3), 3,
rhs_3'Access, null);
+ Table.States (160).Kernel := To_Vector ((0 => (46, 11, 0, False)));
+ Table.States (160).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 46, 3)));
+ Table.States (161).Action_List.Set_Capacity (9);
+ Add_Action (Table.States (161), 12, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (161), 18, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (161), 19, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (161), 20, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (161), 21, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (161), 22, 189);
+ Add_Action (Table.States (161), 26, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (161), 33, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (161), 35, Reduce, (53, 0), 3, null,
null);
+ Table.States (161).Kernel := To_Vector (((53, 26, 0, False), (53,
26, 1, False)));
+ Table.States (161).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 53, 3)));
+ Table.States (162).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (162), (12, 18, 19, 20, 21, 26, 33, 35),
(52, 0), 3, null, null);
+ Table.States (162).Kernel := To_Vector ((0 => (52, 27, 0, False)));
+ Table.States (162).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 52, 3)));
+ Table.States (163).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (163), 12, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (163), 18, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (163), 19, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (163), 20, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (163), 21, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (163), 24, 190);
+ Add_Action (Table.States (163), 25, 191);
+ Add_Action (Table.States (163), 26, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (163), 31, 192);
+ Add_Action (Table.States (163), 33, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (163), 35, Reduce, (51, 0), 3, null,
null);
+ Table.States (163).Kernel := To_Vector (((51, 28, 0, False), (52,
28, 1, False), (53, 28, 1, False), (53,
+ 28, 1, False)));
+ Table.States (163).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 51, 3)));
+ Table.States (164).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (164), 33, 193);
+ Table.States (164).Kernel := To_Vector ((0 => (47, 16, 2, False)));
+ Table.States (164).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 193)));
+ Table.States (165).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (165), 12, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (165), 18, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (165), 19, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (165), 20, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (165), 21, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (165), 24, 123);
+ Add_Action (Table.States (165), 25, 124);
+ Add_Action (Table.States (165), 26, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (165), 31, 125);
+ Add_Action (Table.States (165), 33, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (165), 35, Reduce, (50, 0), 1, null,
null);
+ Table.States (165).Kernel := To_Vector (((50, 33, 0, False), (52,
33, 1, False), (53, 33, 1, False), (53,
+ 33, 1, False)));
+ Table.States (165).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (166).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (166), (12, 18, 19, 20, 21, 26, 33, 35),
(48, 1), 3, null, null);
+ Table.States (166).Kernel := To_Vector ((0 => (48, 50, 0, False)));
+ Table.States (166).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 48, 3)));
+ Table.States (167).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (167), 12, Reduce, (54, 1), 3, null,
null);
+ Add_Action (Table.States (167), 18, 61);
+ Add_Action (Table.States (167), 19, 62);
+ Add_Action (Table.States (167), 20, 63);
+ Add_Action (Table.States (167), 21, 64);
+ Add_Action (Table.States (167), 26, Reduce, (54, 1), 3, null,
null);
+ Add_Action (Table.States (167), 33, 65);
+ Add_Action (Table.States (167), 35, 66);
+ Table.States (167).Goto_List.Set_Capacity (6);
+ Add_Goto (Table.States (167), 47, 67);
+ Add_Goto (Table.States (167), 48, 127);
+ Add_Goto (Table.States (167), 50, 70);
+ Add_Goto (Table.States (167), 51, 71);
+ Add_Goto (Table.States (167), 52, 72);
+ Add_Goto (Table.States (167), 53, 73);
+ Table.States (167).Kernel := To_Vector (((49, 49, 1, True), (54,
49, 0, True)));
+ Table.States (167).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 54, 3)));
+ Table.States (167).Minimal_Complete_Actions_Recursive := True;
+ Table.States (168).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (168), (11, 12, 18, 19, 20, 21, 23, 29,
33, 35, 36), (53, 1), 4, null, null);
+ Table.States (168).Kernel := To_Vector ((0 => (53, 22, 0, False)));
+ Table.States (168).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 53, 4)));
+ Table.States (169).Action_List.Set_Capacity (9);
+ Add_Action (Table.States (169), 12, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (169), 18, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (169), 19, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (169), 20, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (169), 21, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (169), 22, 194);
+ Add_Action (Table.States (169), 27, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (169), 33, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (169), 35, Reduce, (53, 0), 3, null,
null);
+ Table.States (169).Kernel := To_Vector (((53, 26, 0, False), (53,
26, 1, False)));
+ Table.States (169).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 53, 3)));
+ Table.States (170).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (170), (12, 18, 19, 20, 21, 27, 33, 35),
(52, 0), 3, null, null);
+ Table.States (170).Kernel := To_Vector ((0 => (52, 27, 0, False)));
+ Table.States (170).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 52, 3)));
+ Table.States (171).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (171), 12, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (171), 18, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (171), 19, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (171), 20, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (171), 21, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (171), 24, 195);
+ Add_Action (Table.States (171), 25, 196);
+ Add_Action (Table.States (171), 27, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (171), 31, 197);
+ Add_Action (Table.States (171), 33, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (171), 35, Reduce, (51, 0), 3, null,
null);
+ Table.States (171).Kernel := To_Vector (((51, 28, 0, False), (52,
28, 1, False), (53, 28, 1, False), (53,
+ 28, 1, False)));
+ Table.States (171).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 51, 3)));
+ Table.States (172).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (172), 33, 198);
+ Table.States (172).Kernel := To_Vector ((0 => (47, 16, 2, False)));
+ Table.States (172).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 198)));
+ Table.States (173).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (173), 12, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (173), 18, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (173), 19, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (173), 20, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (173), 21, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (173), 24, 135);
+ Add_Action (Table.States (173), 25, 136);
+ Add_Action (Table.States (173), 27, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (173), 31, 137);
+ Add_Action (Table.States (173), 33, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (173), 35, Reduce, (50, 0), 1, null,
null);
+ Table.States (173).Kernel := To_Vector (((50, 33, 0, False), (52,
33, 1, False), (53, 33, 1, False), (53,
+ 33, 1, False)));
+ Table.States (173).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (174).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (174), (12, 18, 19, 20, 21, 27, 33, 35),
(48, 1), 3, null, null);
+ Table.States (174).Kernel := To_Vector ((0 => (48, 50, 0, False)));
+ Table.States (174).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 48, 3)));
+ Table.States (175).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (175), 12, Reduce, (54, 1), 3, null,
null);
+ Add_Action (Table.States (175), 18, 75);
+ Add_Action (Table.States (175), 19, 76);
+ Add_Action (Table.States (175), 20, 77);
+ Add_Action (Table.States (175), 21, 78);
+ Add_Action (Table.States (175), 27, Reduce, (54, 1), 3, null,
null);
+ Add_Action (Table.States (175), 33, 79);
+ Add_Action (Table.States (175), 35, 80);
+ Table.States (175).Goto_List.Set_Capacity (6);
+ Add_Goto (Table.States (175), 47, 81);
+ Add_Goto (Table.States (175), 48, 139);
+ Add_Goto (Table.States (175), 50, 84);
+ Add_Goto (Table.States (175), 51, 85);
+ Add_Goto (Table.States (175), 52, 86);
+ Add_Goto (Table.States (175), 53, 87);
+ Table.States (175).Kernel := To_Vector (((49, 49, 1, True), (54,
49, 0, True)));
+ Table.States (175).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 54, 3)));
+ Table.States (175).Minimal_Complete_Actions_Recursive := True;
+ end Subr_2;
+ procedure Subr_3
+ is begin
+ Table.States (176).Action_List.Set_Capacity (9);
+ Add_Action (Table.States (176), 12, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (176), 18, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (176), 19, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (176), 20, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (176), 21, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (176), 22, 199);
+ Add_Action (Table.States (176), 28, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (176), 33, Reduce, (53, 0), 3, null,
null);
+ Add_Action (Table.States (176), 35, Reduce, (53, 0), 3, null,
null);
+ Table.States (176).Kernel := To_Vector (((53, 26, 0, False), (53,
26, 1, False)));
+ Table.States (176).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 53, 3)));
+ Table.States (177).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (177), (12, 18, 19, 20, 21, 28, 33, 35),
(52, 0), 3, null, null);
+ Table.States (177).Kernel := To_Vector ((0 => (52, 27, 0, False)));
+ Table.States (177).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 52, 3)));
+ Table.States (178).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (178), 12, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (178), 18, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (178), 19, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (178), 20, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (178), 21, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (178), 24, 200);
+ Add_Action (Table.States (178), 25, 201);
+ Add_Action (Table.States (178), 28, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (178), 31, 202);
+ Add_Action (Table.States (178), 33, Reduce, (51, 0), 3, null,
null);
+ Add_Action (Table.States (178), 35, Reduce, (51, 0), 3, null,
null);
+ Table.States (178).Kernel := To_Vector (((51, 28, 0, False), (52,
28, 1, False), (53, 28, 1, False), (53,
+ 28, 1, False)));
+ Table.States (178).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 51, 3)));
+ Table.States (179).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (179), 33, 203);
+ Table.States (179).Kernel := To_Vector ((0 => (47, 16, 2, False)));
+ Table.States (179).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 203)));
+ Table.States (180).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (180), 12, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (180), 18, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (180), 19, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (180), 20, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (180), 21, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (180), 24, 147);
+ Add_Action (Table.States (180), 25, 148);
+ Add_Action (Table.States (180), 28, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (180), 31, 149);
+ Add_Action (Table.States (180), 33, Reduce, (50, 0), 1, null,
null);
+ Add_Action (Table.States (180), 35, Reduce, (50, 0), 1, null,
null);
+ Table.States (180).Kernel := To_Vector (((50, 33, 0, False), (52,
33, 1, False), (53, 33, 1, False), (53,
+ 33, 1, False)));
+ Table.States (180).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 50, 1)));
+ Table.States (181).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (181), (12, 18, 19, 20, 21, 28, 33, 35),
(48, 1), 3, null, null);
+ Table.States (181).Kernel := To_Vector ((0 => (48, 50, 0, False)));
+ Table.States (181).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 48, 3)));
+ Table.States (182).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (182), 12, Reduce, (54, 1), 3, null,
null);
+ Add_Action (Table.States (182), 18, 89);
+ Add_Action (Table.States (182), 19, 90);
+ Add_Action (Table.States (182), 20, 91);
+ Add_Action (Table.States (182), 21, 92);
+ Add_Action (Table.States (182), 28, Reduce, (54, 1), 3, null,
null);
+ Add_Action (Table.States (182), 33, 93);
+ Add_Action (Table.States (182), 35, 94);
+ Table.States (182).Goto_List.Set_Capacity (6);
+ Add_Goto (Table.States (182), 47, 95);
+ Add_Goto (Table.States (182), 48, 151);
+ Add_Goto (Table.States (182), 50, 98);
+ Add_Goto (Table.States (182), 51, 99);
+ Add_Goto (Table.States (182), 52, 100);
+ Add_Goto (Table.States (182), 53, 101);
+ Table.States (182).Kernel := To_Vector (((49, 49, 1, True), (54,
49, 0, True)));
+ Table.States (182).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 54, 3)));
+ Table.States (182).Minimal_Complete_Actions_Recursive := True;
+ Table.States (183).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (183), (11, 12, 18, 19, 20, 21, 23, 29,
33, 35, 36), (53, 2), 4, null, null);
+ Table.States (183).Kernel := To_Vector ((0 => (53, 24, 0, False)));
+ Table.States (183).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 53, 4)));
+ Table.States (184).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (184), (11, 12, 18, 19, 20, 21, 23, 29,
33, 35, 36), (52, 1), 4, null, null);
+ Table.States (184).Kernel := To_Vector ((0 => (52, 25, 0, False)));
+ Table.States (184).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 52, 4)));
+ Table.States (185).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (185), (11, 12, 18, 19, 20, 21, 23, 29,
33, 35, 36), (53, 3), 4, null, null);
+ Table.States (185).Kernel := To_Vector ((0 => (53, 31, 0, False)));
+ Table.States (185).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 53, 4)));
+ Table.States (186).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (186), 17, 204);
+ Table.States (186).Kernel := To_Vector ((0 => (47, 33, 1, False)));
+ Table.States (186).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 17, 204)));
+ Table.States (187).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (187), (12, 23, 29, 33, 36), (45, 3), 4,
null, null);
+ Table.States (187).Kernel := To_Vector ((0 => (45, 5, 0, True)));
+ Table.States (187).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 45, 4)));
+ Table.States (187).Minimal_Complete_Actions_Recursive := True;
+ Table.States (188).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (188), 16, 205);
+ Table.States (188).Kernel := To_Vector ((0 => (45, 33, 2, True)));
+ Table.States (188).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 16, 205)));
+ Table.States (188).Minimal_Complete_Actions_Recursive := True;
+ Table.States (189).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (189), (12, 18, 19, 20, 21, 26, 33, 35),
(53, 1), 4, null, null);
+ Table.States (189).Kernel := To_Vector ((0 => (53, 22, 0, False)));
+ Table.States (189).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 53, 4)));
+ Table.States (190).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (190), (12, 18, 19, 20, 21, 26, 33, 35),
(53, 2), 4, null, null);
+ Table.States (190).Kernel := To_Vector ((0 => (53, 24, 0, False)));
+ Table.States (190).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 53, 4)));
+ Table.States (191).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (191), (12, 18, 19, 20, 21, 26, 33, 35),
(52, 1), 4, null, null);
+ Table.States (191).Kernel := To_Vector ((0 => (52, 25, 0, False)));
+ Table.States (191).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 52, 4)));
+ Table.States (192).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (192), (12, 18, 19, 20, 21, 26, 33, 35),
(53, 3), 4, null, null);
+ Table.States (192).Kernel := To_Vector ((0 => (53, 31, 0, False)));
+ Table.States (192).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 53, 4)));
+ Table.States (193).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (193), 17, 206);
+ Table.States (193).Kernel := To_Vector ((0 => (47, 33, 1, False)));
+ Table.States (193).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 17, 206)));
+ Table.States (194).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (194), (12, 18, 19, 20, 21, 27, 33, 35),
(53, 1), 4, null, null);
+ Table.States (194).Kernel := To_Vector ((0 => (53, 22, 0, False)));
+ Table.States (194).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 53, 4)));
+ Table.States (195).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (195), (12, 18, 19, 20, 21, 27, 33, 35),
(53, 2), 4, null, null);
+ Table.States (195).Kernel := To_Vector ((0 => (53, 24, 0, False)));
+ Table.States (195).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 53, 4)));
+ Table.States (196).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (196), (12, 18, 19, 20, 21, 27, 33, 35),
(52, 1), 4, null, null);
+ Table.States (196).Kernel := To_Vector ((0 => (52, 25, 0, False)));
+ Table.States (196).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 52, 4)));
+ Table.States (197).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (197), (12, 18, 19, 20, 21, 27, 33, 35),
(53, 3), 4, null, null);
+ Table.States (197).Kernel := To_Vector ((0 => (53, 31, 0, False)));
+ Table.States (197).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 53, 4)));
+ Table.States (198).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (198), 17, 207);
+ Table.States (198).Kernel := To_Vector ((0 => (47, 33, 1, False)));
+ Table.States (198).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 17, 207)));
+ Table.States (199).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (199), (12, 18, 19, 20, 21, 28, 33, 35),
(53, 1), 4, null, null);
+ Table.States (199).Kernel := To_Vector ((0 => (53, 22, 0, False)));
+ Table.States (199).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 53, 4)));
+ Table.States (200).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (200), (12, 18, 19, 20, 21, 28, 33, 35),
(53, 2), 4, null, null);
+ Table.States (200).Kernel := To_Vector ((0 => (53, 24, 0, False)));
+ Table.States (200).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 53, 4)));
+ Table.States (201).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (201), (12, 18, 19, 20, 21, 28, 33, 35),
(52, 1), 4, null, null);
+ Table.States (201).Kernel := To_Vector ((0 => (52, 25, 0, False)));
+ Table.States (201).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 52, 4)));
+ Table.States (202).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (202), (12, 18, 19, 20, 21, 28, 33, 35),
(53, 3), 4, null, null);
+ Table.States (202).Kernel := To_Vector ((0 => (53, 31, 0, False)));
+ Table.States (202).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 53, 4)));
+ Table.States (203).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (203), 17, 208);
+ Table.States (203).Kernel := To_Vector ((0 => (47, 33, 1, False)));
+ Table.States (203).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 17, 208)));
+ Table.States (204).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (204), (11, 12, 18, 19, 20, 21, 23, 29,
33, 35, 36), (47, 0), 5, null, null);
+ Table.States (204).Kernel := To_Vector ((0 => (47, 17, 0, False)));
+ Table.States (204).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 47, 5)));
+ Table.States (205).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (205), 33, 209);
+ Table.States (205).Kernel := To_Vector ((0 => (45, 16, 1, True)));
+ Table.States (205).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, 33, 209)));
+ Table.States (205).Minimal_Complete_Actions_Recursive := True;
+ Table.States (206).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (206), (12, 18, 19, 20, 21, 26, 33, 35),
(47, 0), 5, null, null);
+ Table.States (206).Kernel := To_Vector ((0 => (47, 17, 0, False)));
+ Table.States (206).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 47, 5)));
+ Table.States (207).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (207), (12, 18, 19, 20, 21, 27, 33, 35),
(47, 0), 5, null, null);
+ Table.States (207).Kernel := To_Vector ((0 => (47, 17, 0, False)));
+ Table.States (207).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 47, 5)));
+ Table.States (208).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (208), (12, 18, 19, 20, 21, 28, 33, 35),
(47, 0), 5, null, null);
+ Table.States (208).Kernel := To_Vector ((0 => (47, 17, 0, False)));
+ Table.States (208).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 47, 5)));
+ Table.States (209).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (209), (12, 23, 29, 33, 36), (45, 2), 6,
null, null);
+ Table.States (209).Kernel := To_Vector ((0 => (45, 33, 0, True)));
+ Table.States (209).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, 45, 6)));
+ Table.States (209).Minimal_Complete_Actions_Recursive := True;
+ end Subr_3;
+ begin
+ Subr_1;
+ Subr_2;
+ Subr_3;
+ Table.Error_Action := new Parse_Action_Node'((Verb => Error), null);
+ end;
+
+ WisiToken.Parse.LR.Parser.New_Parser
+ (Parser,
+ Trace,
+ Lexer.New_Lexer (Trace.Descriptor),
+ Table,
+ Language_Fixes,
+ Language_Matching_Begin_Tokens,
+ Language_String_ID_Set,
+ User_Data,
+ Max_Parallel => 15,
+ Terminate_Same_State => True);
+ end Create_Parser;
+end Wisitoken_Grammar_1_Process_Main;
diff --git a/wisitoken_grammar_1_process_main.ads
b/wisitoken_grammar_1_process_main.ads
new file mode 100644
index 0000000..c0bbfa5
--- /dev/null
+++ b/wisitoken_grammar_1_process_main.ads
@@ -0,0 +1,36 @@
+-- generated parser support file.
+-- command line: wisitoken-bnf-generate.exe --generate LR1 Ada_Emacs re2c
PROCESS wisitoken_grammar_1.wy
+--
+
+-- 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/>.
+
+with WisiToken.Syntax_Trees;
+with WisiToken.Parse.LR.Parser;
+package Wisitoken_Grammar_1_Process_Main is
+
+ procedure Create_Parser
+ (Parser : out WisiToken.Parse.LR.Parser.Parser;
+ Language_Fixes : in
WisiToken.Parse.LR.Parser.Language_Fixes_Access;
+ Language_Matching_Begin_Tokens : in
WisiToken.Parse.LR.Parser.Language_Matching_Begin_Tokens_Access;
+ Language_String_ID_Set : in
WisiToken.Parse.LR.Parser.Language_String_ID_Set_Access;
+ Trace : not null access WisiToken.Trace'Class;
+ User_Data : in
WisiToken.Syntax_Trees.User_Data_Access);
+
+end Wisitoken_Grammar_1_Process_Main;
diff --git a/wisitoken_grammar_1_re2c.c b/wisitoken_grammar_1_re2c.c
new file mode 100644
index 0000000..9cfbf31
--- /dev/null
+++ b/wisitoken_grammar_1_re2c.c
@@ -0,0 +1,4299 @@
+/* Generated by re2c 1.0.3 */
+#line 1 "wisitoken_grammar_1.re2c"
+// generated parser support file. -*- mode: C -*-
+// command line: wisitoken-bnf-generate.exe --generate LR1 Ada_Emacs re2c
PROCESS wisitoken_grammar_1.wy
+//
+
+// 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/>.
+
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct wisi_lexer
+{
+ unsigned char* buffer; // input text, in utf-8 encoding
+ unsigned char* buffer_last; // last byte in buffer
+ unsigned char* cursor; // current byte
+ unsigned char* byte_token_start; // byte position at start of current token
+ size_t char_pos; // character position of current character
+ size_t char_token_start; // character position at start of current
token
+ int line; // 1 indexed
+ int line_token_start; // line at start of current token
+ unsigned char* marker; // saved cursor
+ size_t marker_pos; // saved character position
+ size_t marker_line; // saved line
+ unsigned char* context; // saved cursor
+ size_t context_pos; // saved character position
+ int context_line; // saved line
+ int verbosity;
+
+} wisi_lexer;
+
+#define YYCTYPE unsigned char
+
+#define NO_ERROR 0
+#define ERROR_unrecognized_character 1
+wisi_lexer* wisitoken_grammar_1_new_lexer
+ (unsigned char* input, size_t length, int verbosity)
+{
+ wisi_lexer* result = malloc (sizeof (wisi_lexer));
+ result->buffer = input;
+ result->buffer_last = input + length - 1;
+ result->cursor = input;
+ result->byte_token_start = input;
+ result->char_pos = 1;
+ result->char_token_start = 1;
+ result->line = (*result->cursor == 0x0A) ? 2 : 1;
+ result->line_token_start = result->line;
+ result->verbosity = verbosity;
+ return result;
+}
+
+void
+wisitoken_grammar_1_free_lexer(wisi_lexer** lexer)
+{
+ free(*lexer);
+ *lexer = 0;
+}
+
+void
+wisitoken_grammar_1_reset_lexer(wisi_lexer* lexer)
+{
+ lexer->cursor = lexer->buffer;
+ lexer->char_pos = 1;
+ lexer->line = (*lexer->cursor == 0x0A) ? 2 : 1;
+}
+
+static void debug(wisi_lexer* lexer, int state, unsigned char ch)
+{
+ if (lexer->verbosity > 0)
+ {
+ if (ch < ' ')
+ printf ("lexer: %d, 0x%x\n", state, ch);
+ else
+ printf ("lexer: %d, '%c' 0x%x\n", state, ch, ch);
+ }
+}
+#define YYDEBUG(state, ch) debug(lexer, state, ch)
+#define YYCURSOR lexer->cursor
+
+#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;
+ }
+}
+#define YYSKIP() skip(lexer)
+#define YYBACKUP() lexer->marker = lexer->cursor; lexer->marker_pos =
lexer->char_pos;lexer->marker_line = lexer->line
+#define YYRESTORE() lexer->cursor = lexer->marker; lexer->char_pos =
lexer->marker_pos;lexer->line = lexer->marker_line
+#define YYBACKUPCTX() lexer->context = lexer->cursor; lexer->context_pos =
lexer->char_pos;lexer->context_line = lexer->line
+#define YYRESTORECTX() lexer->cursor = lexer->context; lexer->char_pos =
lexer->context_pos;lexer->line = lexer->context_line
+
+static void skip_to(wisi_lexer* lexer, char* target)
+{
+ int i;
+
+ while (lexer->cursor <= lexer->buffer_last)
+ {
+ if (*lexer->cursor == target[0])
+ {
+ i = 0;
+ do
+ i++;
+ while (0 != target[i] &&
+ lexer->cursor + i <= lexer->buffer_last &&
+ *(lexer->cursor + i) == target[i]);
+
+ if (0 == target[i])
+ {
+ for (i = 0; 0 != target[i]; i++)
+ skip(lexer);
+ break;
+ }
+ }
+ skip(lexer);
+ };
+}
+
+int wisitoken_grammar_1_next_token
+ (wisi_lexer* lexer,
+ int* id,
+ size_t* byte_position,
+ size_t* byte_length,
+ size_t* char_position,
+ size_t* char_length,
+ int* line_start)
+{
+ int status = NO_ERROR;
+ *id = -1;
+ if (lexer->cursor > lexer->buffer_last)
+ {
+ *id = 36;
+ *byte_position = lexer->buffer_last - lexer->buffer + 1;
+ *byte_length = 0;
+ *char_position = lexer->char_token_start;
+ *char_length = 0;
+ *line_start = lexer->line;
+ return status;
+ }
+
+ lexer->byte_token_start = lexer->cursor;
+ lexer->char_token_start = lexer->char_pos;
+ if (*lexer->cursor == 0x0A)
+ lexer->line_token_start = lexer->line-1;
+ else
+ lexer->line_token_start = lexer->line;
+
+ while (*id == -1 && status == 0)
+ {
+
+#line 177 "wisitoken_grammar_1_re2c.c"
+{
+ YYCTYPE yych;
+ unsigned int yyaccept = 0;
+ YYDEBUG(0, *YYCURSOR);
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0x04: goto yy4;
+ case '\t':
+ case ' ': goto yy6;
+ case '\n': goto yy8;
+ case '\r': goto yy10;
+ case '"': goto yy11;
+ case '%': goto yy12;
+ case '\'': goto yy14;
+ case '(': goto yy15;
+ case ')': goto yy17;
+ case '*': goto yy19;
+ case '+': goto yy21;
+ case ',': goto yy23;
+ case '-': goto yy25;
+ case '/': goto yy27;
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9': goto yy29;
+ case ':': goto yy32;
+ case ';': goto yy34;
+ case '<': goto yy36;
+ case '=': goto yy38;
+ case '>': goto yy40;
+ case '?': goto yy42;
+ case 'A':
+ case 'B':
+ case 'C':
+ case 'D':
+ case 'E':
+ case 'F':
+ case 'G':
+ case 'H':
+ case 'I':
+ case 'J':
+ case 'K':
+ case 'L':
+ case 'M':
+ case 'N':
+ case 'O':
+ case 'P':
+ case 'Q':
+ case 'R':
+ case 'S':
+ case 'T':
+ case 'U':
+ case 'V':
+ case 'W':
+ case 'X':
+ case 'Y':
+ case 'Z':
+ case 'a':
+ case 'b':
+ case 'd':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'j':
+ case 'l':
+ case 'm':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z': goto yy44;
+ case '[': goto yy47;
+ case ']': goto yy49;
+ case 'c': goto yy51;
+ case 'e': goto yy52;
+ case 'i': goto yy53;
+ case 'k': goto yy54;
+ case 'n': goto yy55;
+ case 't': goto yy56;
+ case '{': goto yy57;
+ case '|': goto yy59;
+ case '}': goto yy61;
+ case 0xC2:
+ case 0xC3:
+ case 0xC4:
+ case 0xC5:
+ case 0xC6:
+ case 0xC7:
+ case 0xC8:
+ case 0xC9:
+ case 0xCA:
+ case 0xCB:
+ case 0xCC:
+ case 0xCD:
+ case 0xCE:
+ case 0xCF:
+ case 0xD0:
+ case 0xD1:
+ case 0xD2:
+ case 0xD3:
+ case 0xD4:
+ case 0xD5:
+ case 0xD6:
+ case 0xD7:
+ case 0xD8:
+ case 0xD9:
+ case 0xDA:
+ case 0xDB:
+ case 0xDC:
+ case 0xDD:
+ case 0xDE:
+ case 0xDF: goto yy63;
+ case 0xE0: goto yy64;
+ case 0xE1:
+ case 0xE2:
+ case 0xE3:
+ case 0xE4:
+ case 0xE5:
+ case 0xE6:
+ case 0xE7:
+ case 0xE8:
+ case 0xE9:
+ case 0xEA:
+ case 0xEB:
+ case 0xEC:
+ case 0xED:
+ case 0xEE:
+ case 0xEF: goto yy65;
+ case 0xF0: goto yy66;
+ case 0xF1:
+ case 0xF2:
+ case 0xF3: goto yy67;
+ case 0xF4: goto yy68;
+ default: goto yy2;
+ }
+yy2:
+ YYDEBUG(2, YYPEEK ());
+ YYSKIP ();
+yy3:
+ YYDEBUG(3, YYPEEK ());
+#line 255 "wisitoken_grammar_1.re2c"
+ {status = ERROR_unrecognized_character; continue;}
+#line 332 "wisitoken_grammar_1_re2c.c"
+yy4:
+ YYDEBUG(4, YYPEEK ());
+ YYSKIP ();
+ YYDEBUG(5, YYPEEK ());
+#line 253 "wisitoken_grammar_1.re2c"
+ {*id = 36; continue;}
+#line 339 "wisitoken_grammar_1_re2c.c"
+yy6:
+ YYDEBUG(6, YYPEEK ());
+ YYSKIP ();
+ YYDEBUG(7, YYPEEK ());
+#line 211 "wisitoken_grammar_1.re2c"
+ { lexer->byte_token_start = lexer->cursor;
+ lexer->char_token_start = lexer->char_pos;
+ if (*lexer->cursor == 0x0A)
+ lexer->line_token_start = lexer->line-1;
+ else
+ lexer->line_token_start = lexer->line;
+ continue; }
+#line 352 "wisitoken_grammar_1_re2c.c"
+yy8:
+ YYDEBUG(8, YYPEEK ());
+ YYSKIP ();
+ YYDEBUG(9, YYPEEK ());
+#line 218 "wisitoken_grammar_1.re2c"
+ {*id = 1; continue;}
+#line 359 "wisitoken_grammar_1_re2c.c"
+yy10:
+ YYDEBUG(10, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case '\n': goto yy8;
+ default: goto yy3;
+ }
+yy11:
+ YYDEBUG(11, YYPEEK ());
+ yyaccept = 0;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case ' ':
+ case '!':
+ case '"':
+ case '#':
+ case '$':
+ case '%':
+ case '&':
+ case '\'':
+ case '(':
+ case ')':
+ case '*':
+ case '+':
+ case ',':
+ case '-':
+ case '.':
+ case '/':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case ':':
+ case ';':
+ case '<':
+ case '=':
+ case '>':
+ case '?':
+ case '@':
+ case 'A':
+ case 'B':
+ case 'C':
+ case 'D':
+ case 'E':
+ case 'F':
+ case 'G':
+ case 'H':
+ case 'I':
+ case 'J':
+ case 'K':
+ case 'L':
+ case 'M':
+ case 'N':
+ case 'O':
+ case 'P':
+ case 'Q':
+ case 'R':
+ case 'S':
+ case 'T':
+ case 'U':
+ case 'V':
+ case 'W':
+ case 'X':
+ case 'Y':
+ case 'Z':
+ case '[':
+ case '\\':
+ case ']':
+ case '^':
+ case '_':
+ case '`':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ case '{':
+ case '|':
+ case '}':
+ case '~':
+ case 0x7F:
+ case 0xC2:
+ case 0xC3:
+ case 0xC4:
+ case 0xC5:
+ case 0xC6:
+ case 0xC7:
+ case 0xC8:
+ case 0xC9:
+ case 0xCA:
+ case 0xCB:
+ case 0xCC:
+ case 0xCD:
+ case 0xCE:
+ case 0xCF:
+ case 0xD0:
+ case 0xD1:
+ case 0xD2:
+ case 0xD3:
+ case 0xD4:
+ case 0xD5:
+ case 0xD6:
+ case 0xD7:
+ case 0xD8:
+ case 0xD9:
+ case 0xDA:
+ case 0xDB:
+ case 0xDC:
+ case 0xDD:
+ case 0xDE:
+ case 0xDF:
+ case 0xE0:
+ case 0xE1:
+ case 0xE2:
+ case 0xE3:
+ case 0xE4:
+ case 0xE5:
+ case 0xE6:
+ case 0xE7:
+ case 0xE8:
+ case 0xE9:
+ case 0xEA:
+ case 0xEB:
+ case 0xEC:
+ case 0xED:
+ case 0xEE:
+ case 0xEF:
+ case 0xF0:
+ case 0xF1:
+ case 0xF2:
+ case 0xF3:
+ case 0xF4: goto yy70;
+ default: goto yy3;
+ }
+yy12:
+ YYDEBUG(12, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case '(': goto yy80;
+ case '[': goto yy82;
+ case '{': goto yy84;
+ default: goto yy13;
+ }
+yy13:
+ YYDEBUG(13, YYPEEK ());
+#line 240 "wisitoken_grammar_1.re2c"
+ {*id = 23; continue;}
+#line 538 "wisitoken_grammar_1_re2c.c"
+yy14:
+ YYDEBUG(14, YYPEEK ());
+ yyaccept = 0;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case ' ':
+ case '!':
+ case '"':
+ case '#':
+ case '$':
+ case '%':
+ case '&':
+ case '\'':
+ case '(':
+ case ')':
+ case '*':
+ case '+':
+ case ',':
+ case '-':
+ case '.':
+ case '/':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case ':':
+ case ';':
+ case '<':
+ case '=':
+ case '>':
+ case '?':
+ case '@':
+ case 'A':
+ case 'B':
+ case 'C':
+ case 'D':
+ case 'E':
+ case 'F':
+ case 'G':
+ case 'H':
+ case 'I':
+ case 'J':
+ case 'K':
+ case 'L':
+ case 'M':
+ case 'N':
+ case 'O':
+ case 'P':
+ case 'Q':
+ case 'R':
+ case 'S':
+ case 'T':
+ case 'U':
+ case 'V':
+ case 'W':
+ case 'X':
+ case 'Y':
+ case 'Z':
+ case '[':
+ case '\\':
+ case ']':
+ case '^':
+ case '_':
+ case '`':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ case '{':
+ case '|':
+ case '}':
+ case '~':
+ case 0x7F:
+ case 0xC2:
+ case 0xC3:
+ case 0xC4:
+ case 0xC5:
+ case 0xC6:
+ case 0xC7:
+ case 0xC8:
+ case 0xC9:
+ case 0xCA:
+ case 0xCB:
+ case 0xCC:
+ case 0xCD:
+ case 0xCE:
+ case 0xCF:
+ case 0xD0:
+ case 0xD1:
+ case 0xD2:
+ case 0xD3:
+ case 0xD4:
+ case 0xD5:
+ case 0xD6:
+ case 0xD7:
+ case 0xD8:
+ case 0xD9:
+ case 0xDA:
+ case 0xDB:
+ case 0xDC:
+ case 0xDD:
+ case 0xDE:
+ case 0xDF:
+ case 0xE0:
+ case 0xE1:
+ case 0xE2:
+ case 0xE3:
+ case 0xE4:
+ case 0xE5:
+ case 0xE6:
+ case 0xE7:
+ case 0xE8:
+ case 0xE9:
+ case 0xEA:
+ case 0xEB:
+ case 0xEC:
+ case 0xED:
+ case 0xEE:
+ case 0xEF:
+ case 0xF0:
+ case 0xF1:
+ case 0xF2:
+ case 0xF3:
+ case 0xF4: goto yy87;
+ default: goto yy3;
+ }
+yy15:
+ YYDEBUG(15, YYPEEK ());
+ YYSKIP ();
+ YYDEBUG(16, YYPEEK ());
+#line 237 "wisitoken_grammar_1.re2c"
+ {*id = 20; continue;}
+#line 701 "wisitoken_grammar_1_re2c.c"
+yy17:
+ YYDEBUG(17, YYPEEK ());
+ YYSKIP ();
+ YYDEBUG(18, YYPEEK ());
+#line 245 "wisitoken_grammar_1.re2c"
+ {*id = 28; continue;}
+#line 708 "wisitoken_grammar_1_re2c.c"
+yy19:
+ YYDEBUG(19, YYPEEK ());
+ YYSKIP ();
+ YYDEBUG(20, YYPEEK ());
+#line 248 "wisitoken_grammar_1.re2c"
+ {*id = 31; continue;}
+#line 715 "wisitoken_grammar_1_re2c.c"
+yy21:
+ YYDEBUG(21, YYPEEK ());
+ YYSKIP ();
+ YYDEBUG(22, YYPEEK ());
+#line 241 "wisitoken_grammar_1.re2c"
+ {*id = 24; continue;}
+#line 722 "wisitoken_grammar_1_re2c.c"
+yy23:
+ YYDEBUG(23, YYPEEK ());
+ YYSKIP ();
+ YYDEBUG(24, YYPEEK ());
+#line 232 "wisitoken_grammar_1.re2c"
+ {*id = 15; continue;}
+#line 729 "wisitoken_grammar_1_re2c.c"
+yy25:
+ YYDEBUG(25, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case '_': goto yy29;
+ default: goto yy26;
+ }
+yy26:
+ YYDEBUG(26, YYPEEK ());
+#line 239 "wisitoken_grammar_1.re2c"
+ {*id = 22; continue;}
+#line 752 "wisitoken_grammar_1_re2c.c"
+yy27:
+ YYDEBUG(27, YYPEEK ());
+ YYSKIP ();
+ YYDEBUG(28, YYPEEK ());
+#line 247 "wisitoken_grammar_1.re2c"
+ {*id = 30; continue;}
+#line 759 "wisitoken_grammar_1_re2c.c"
+yy29:
+ YYDEBUG(29, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ YYDEBUG(30, YYPEEK ());
+ switch (yych) {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case '_': goto yy29;
+ default: goto yy31;
+ }
+yy31:
+ YYDEBUG(31, YYPEEK ());
+#line 249 "wisitoken_grammar_1.re2c"
+ {*id = 32; continue;}
+#line 783 "wisitoken_grammar_1_re2c.c"
+yy32:
+ YYDEBUG(32, YYPEEK ());
+ yyaccept = 1;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case ':': goto yy96;
+ default: goto yy33;
+ }
+yy33:
+ YYDEBUG(33, YYPEEK ());
+#line 230 "wisitoken_grammar_1.re2c"
+ {*id = 13; continue;}
+#line 798 "wisitoken_grammar_1_re2c.c"
+yy34:
+ YYDEBUG(34, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case ';': goto yy97;
+ default: goto yy35;
+ }
+yy35:
+ YYDEBUG(35, YYPEEK ());
+#line 246 "wisitoken_grammar_1.re2c"
+ {*id = 29; continue;}
+#line 811 "wisitoken_grammar_1_re2c.c"
+yy36:
+ YYDEBUG(36, YYPEEK ());
+ YYSKIP ();
+ YYDEBUG(37, YYPEEK ());
+#line 238 "wisitoken_grammar_1.re2c"
+ {*id = 21; continue;}
+#line 818 "wisitoken_grammar_1_re2c.c"
+yy38:
+ YYDEBUG(38, YYPEEK ());
+ YYSKIP ();
+ YYDEBUG(39, YYPEEK ());
+#line 233 "wisitoken_grammar_1.re2c"
+ {*id = 16; continue;}
+#line 825 "wisitoken_grammar_1_re2c.c"
+yy40:
+ YYDEBUG(40, YYPEEK ());
+ YYSKIP ();
+ YYDEBUG(41, YYPEEK ());
+#line 234 "wisitoken_grammar_1.re2c"
+ {*id = 17; continue;}
+#line 832 "wisitoken_grammar_1_re2c.c"
+yy42:
+ YYDEBUG(42, YYPEEK ());
+ YYSKIP ();
+ YYDEBUG(43, YYPEEK ());
+#line 242 "wisitoken_grammar_1.re2c"
+ {*id = 25; continue;}
+#line 839 "wisitoken_grammar_1_re2c.c"
+yy44:
+ YYDEBUG(44, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+yy45:
+ YYDEBUG(45, YYPEEK ());
+ switch (yych) {
+ case '-':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case 'A':
+ case 'B':
+ case 'C':
+ case 'D':
+ case 'E':
+ case 'F':
+ case 'G':
+ case 'H':
+ case 'I':
+ case 'J':
+ case 'K':
+ case 'L':
+ case 'M':
+ case 'N':
+ case 'O':
+ case 'P':
+ case 'Q':
+ case 'R':
+ case 'S':
+ case 'T':
+ case 'U':
+ case 'V':
+ case 'W':
+ case 'X':
+ case 'Y':
+ case 'Z':
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z': goto yy44;
+ case 0xC2:
+ case 0xC3:
+ case 0xC4:
+ case 0xC5:
+ case 0xC6:
+ case 0xC7:
+ case 0xC8:
+ case 0xC9:
+ case 0xCA:
+ case 0xCB:
+ case 0xCC:
+ case 0xCD:
+ case 0xCE:
+ case 0xCF:
+ case 0xD0:
+ case 0xD1:
+ case 0xD2:
+ case 0xD3:
+ case 0xD4:
+ case 0xD5:
+ case 0xD6:
+ case 0xD7:
+ case 0xD8:
+ case 0xD9:
+ case 0xDA:
+ case 0xDB:
+ case 0xDC:
+ case 0xDD:
+ case 0xDE:
+ case 0xDF: goto yy100;
+ case 0xE0: goto yy101;
+ case 0xE1:
+ case 0xE2:
+ case 0xE3:
+ case 0xE4:
+ case 0xE5:
+ case 0xE6:
+ case 0xE7:
+ case 0xE8:
+ case 0xE9:
+ case 0xEA:
+ case 0xEB:
+ case 0xEC:
+ case 0xED:
+ case 0xEE:
+ case 0xEF: goto yy102;
+ case 0xF0: goto yy103;
+ case 0xF1:
+ case 0xF2:
+ case 0xF3: goto yy104;
+ case 0xF4: goto yy105;
+ default: goto yy46;
+ }
+yy46:
+ YYDEBUG(46, YYPEEK ());
+#line 250 "wisitoken_grammar_1.re2c"
+ {*id = 33; continue;}
+#line 970 "wisitoken_grammar_1_re2c.c"
+yy47:
+ YYDEBUG(47, YYPEEK ());
+ YYSKIP ();
+ YYDEBUG(48, YYPEEK ());
+#line 236 "wisitoken_grammar_1.re2c"
+ {*id = 19; continue;}
+#line 977 "wisitoken_grammar_1_re2c.c"
+yy49:
+ YYDEBUG(49, YYPEEK ());
+ YYSKIP ();
+ YYDEBUG(50, YYPEEK ());
+#line 244 "wisitoken_grammar_1.re2c"
+ {*id = 27; continue;}
+#line 984 "wisitoken_grammar_1_re2c.c"
+yy51:
+ YYDEBUG(51, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'o': goto yy106;
+ default: goto yy45;
+ }
+yy52:
+ YYDEBUG(52, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'n': goto yy107;
+ default: goto yy45;
+ }
+yy53:
+ YYDEBUG(53, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'f': goto yy108;
+ default: goto yy45;
+ }
+yy54:
+ YYDEBUG(54, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'e': goto yy110;
+ default: goto yy45;
+ }
+yy55:
+ YYDEBUG(55, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'o': goto yy111;
+ default: goto yy45;
+ }
+yy56:
+ YYDEBUG(56, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'o': goto yy112;
+ default: goto yy45;
+ }
+yy57:
+ YYDEBUG(57, YYPEEK ());
+ YYSKIP ();
+ YYDEBUG(58, YYPEEK ());
+#line 235 "wisitoken_grammar_1.re2c"
+ {*id = 18; continue;}
+#line 1051 "wisitoken_grammar_1_re2c.c"
+yy59:
+ YYDEBUG(59, YYPEEK ());
+ YYSKIP ();
+ YYDEBUG(60, YYPEEK ());
+#line 229 "wisitoken_grammar_1.re2c"
+ {*id = 12; continue;}
+#line 1058 "wisitoken_grammar_1_re2c.c"
+yy61:
+ YYDEBUG(61, YYPEEK ());
+ YYSKIP ();
+ YYDEBUG(62, YYPEEK ());
+#line 243 "wisitoken_grammar_1.re2c"
+ {*id = 26; continue;}
+#line 1065 "wisitoken_grammar_1_re2c.c"
+yy63:
+ YYDEBUG(63, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0x80:
+ case 0x81:
+ case 0x82:
+ case 0x83:
+ case 0x84:
+ case 0x85:
+ case 0x86:
+ case 0x87:
+ case 0x88:
+ case 0x89:
+ case 0x8A:
+ case 0x8B:
+ case 0x8C:
+ case 0x8D:
+ case 0x8E:
+ case 0x8F:
+ case 0x90:
+ case 0x91:
+ case 0x92:
+ case 0x93:
+ case 0x94:
+ case 0x95:
+ case 0x96:
+ case 0x97:
+ case 0x98:
+ case 0x99:
+ case 0x9A:
+ case 0x9B:
+ case 0x9C:
+ case 0x9D:
+ case 0x9E:
+ case 0x9F:
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF: goto yy44;
+ default: goto yy3;
+ }
+yy64:
+ YYDEBUG(64, YYPEEK ());
+ yyaccept = 0;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF: goto yy100;
+ default: goto yy3;
+ }
+yy65:
+ YYDEBUG(65, YYPEEK ());
+ yyaccept = 0;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0x80:
+ case 0x81:
+ case 0x82:
+ case 0x83:
+ case 0x84:
+ case 0x85:
+ case 0x86:
+ case 0x87:
+ case 0x88:
+ case 0x89:
+ case 0x8A:
+ case 0x8B:
+ case 0x8C:
+ case 0x8D:
+ case 0x8E:
+ case 0x8F:
+ case 0x90:
+ case 0x91:
+ case 0x92:
+ case 0x93:
+ case 0x94:
+ case 0x95:
+ case 0x96:
+ case 0x97:
+ case 0x98:
+ case 0x99:
+ case 0x9A:
+ case 0x9B:
+ case 0x9C:
+ case 0x9D:
+ case 0x9E:
+ case 0x9F:
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF: goto yy100;
+ default: goto yy3;
+ }
+yy66:
+ YYDEBUG(66, YYPEEK ());
+ yyaccept = 0;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0x90:
+ case 0x91:
+ case 0x92:
+ case 0x93:
+ case 0x94:
+ case 0x95:
+ case 0x96:
+ case 0x97:
+ case 0x98:
+ case 0x99:
+ case 0x9A:
+ case 0x9B:
+ case 0x9C:
+ case 0x9D:
+ case 0x9E:
+ case 0x9F:
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF: goto yy102;
+ default: goto yy3;
+ }
+yy67:
+ YYDEBUG(67, YYPEEK ());
+ yyaccept = 0;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0x80:
+ case 0x81:
+ case 0x82:
+ case 0x83:
+ case 0x84:
+ case 0x85:
+ case 0x86:
+ case 0x87:
+ case 0x88:
+ case 0x89:
+ case 0x8A:
+ case 0x8B:
+ case 0x8C:
+ case 0x8D:
+ case 0x8E:
+ case 0x8F:
+ case 0x90:
+ case 0x91:
+ case 0x92:
+ case 0x93:
+ case 0x94:
+ case 0x95:
+ case 0x96:
+ case 0x97:
+ case 0x98:
+ case 0x99:
+ case 0x9A:
+ case 0x9B:
+ case 0x9C:
+ case 0x9D:
+ case 0x9E:
+ case 0x9F:
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF: goto yy102;
+ default: goto yy3;
+ }
+yy68:
+ YYDEBUG(68, YYPEEK ());
+ yyaccept = 0;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0x80:
+ case 0x81:
+ case 0x82:
+ case 0x83:
+ case 0x84:
+ case 0x85:
+ case 0x86:
+ case 0x87:
+ case 0x88:
+ case 0x89:
+ case 0x8A:
+ case 0x8B:
+ case 0x8C:
+ case 0x8D:
+ case 0x8E:
+ case 0x8F: goto yy102;
+ default: goto yy3;
+ }
+yy69:
+ YYDEBUG(69, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+yy70:
+ YYDEBUG(70, YYPEEK ());
+ switch (yych) {
+ case ' ':
+ case '!':
+ case '#':
+ case '$':
+ case '%':
+ case '&':
+ case '\'':
+ case '(':
+ case ')':
+ case '*':
+ case '+':
+ case ',':
+ case '-':
+ case '.':
+ case '/':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case ':':
+ case ';':
+ case '<':
+ case '=':
+ case '>':
+ case '?':
+ case '@':
+ case 'A':
+ case 'B':
+ case 'C':
+ case 'D':
+ case 'E':
+ case 'F':
+ case 'G':
+ case 'H':
+ case 'I':
+ case 'J':
+ case 'K':
+ case 'L':
+ case 'M':
+ case 'N':
+ case 'O':
+ case 'P':
+ case 'Q':
+ case 'R':
+ case 'S':
+ case 'T':
+ case 'U':
+ case 'V':
+ case 'W':
+ case 'X':
+ case 'Y':
+ case 'Z':
+ case '[':
+ case '\\':
+ case ']':
+ case '^':
+ case '_':
+ case '`':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ case '{':
+ case '|':
+ case '}':
+ case '~':
+ case 0x7F: goto yy69;
+ case '"': goto yy72;
+ case 0xC2:
+ case 0xC3:
+ case 0xC4:
+ case 0xC5:
+ case 0xC6:
+ case 0xC7:
+ case 0xC8:
+ case 0xC9:
+ case 0xCA:
+ case 0xCB:
+ case 0xCC:
+ case 0xCD:
+ case 0xCE:
+ case 0xCF:
+ case 0xD0:
+ case 0xD1:
+ case 0xD2:
+ case 0xD3:
+ case 0xD4:
+ case 0xD5:
+ case 0xD6:
+ case 0xD7:
+ case 0xD8:
+ case 0xD9:
+ case 0xDA:
+ case 0xDB:
+ case 0xDC:
+ case 0xDD:
+ case 0xDE:
+ case 0xDF: goto yy74;
+ case 0xE0: goto yy75;
+ case 0xE1:
+ case 0xE2:
+ case 0xE3:
+ case 0xE4:
+ case 0xE5:
+ case 0xE6:
+ case 0xE7:
+ case 0xE8:
+ case 0xE9:
+ case 0xEA:
+ case 0xEB:
+ case 0xEC:
+ case 0xED:
+ case 0xEE:
+ case 0xEF: goto yy76;
+ case 0xF0: goto yy77;
+ case 0xF1:
+ case 0xF2:
+ case 0xF3: goto yy78;
+ case 0xF4: goto yy79;
+ default: goto yy71;
+ }
+yy71:
+ YYDEBUG(71, YYPEEK ());
+ YYRESTORE ();
+ switch (yyaccept) {
+ case 0: goto yy3;
+ case 1: goto yy33;
+ case 2: goto yy46;
+ case 3: goto yy73;
+ case 4: goto yy89;
+ case 5: goto yy99;
+ case 6: goto yy109;
+ case 7: goto yy123;
+ case 8: goto yy128;
+ case 9: goto yy135;
+ case 10: goto yy139;
+ default: goto yy145;
+ }
+yy72:
+ YYDEBUG(72, YYPEEK ());
+ yyaccept = 3;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case '"': goto yy69;
+ default: goto yy73;
+ }
+yy73:
+ YYDEBUG(73, YYPEEK ());
+#line 251 "wisitoken_grammar_1.re2c"
+ {*id = 34; continue;}
+#line 1593 "wisitoken_grammar_1_re2c.c"
+yy74:
+ YYDEBUG(74, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0x80:
+ case 0x81:
+ case 0x82:
+ case 0x83:
+ case 0x84:
+ case 0x85:
+ case 0x86:
+ case 0x87:
+ case 0x88:
+ case 0x89:
+ case 0x8A:
+ case 0x8B:
+ case 0x8C:
+ case 0x8D:
+ case 0x8E:
+ case 0x8F:
+ case 0x90:
+ case 0x91:
+ case 0x92:
+ case 0x93:
+ case 0x94:
+ case 0x95:
+ case 0x96:
+ case 0x97:
+ case 0x98:
+ case 0x99:
+ case 0x9A:
+ case 0x9B:
+ case 0x9C:
+ case 0x9D:
+ case 0x9E:
+ case 0x9F:
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF: goto yy69;
+ default: goto yy71;
+ }
+yy75:
+ YYDEBUG(75, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF: goto yy74;
+ default: goto yy71;
+ }
+yy76:
+ YYDEBUG(76, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0x80:
+ case 0x81:
+ case 0x82:
+ case 0x83:
+ case 0x84:
+ case 0x85:
+ case 0x86:
+ case 0x87:
+ case 0x88:
+ case 0x89:
+ case 0x8A:
+ case 0x8B:
+ case 0x8C:
+ case 0x8D:
+ case 0x8E:
+ case 0x8F:
+ case 0x90:
+ case 0x91:
+ case 0x92:
+ case 0x93:
+ case 0x94:
+ case 0x95:
+ case 0x96:
+ case 0x97:
+ case 0x98:
+ case 0x99:
+ case 0x9A:
+ case 0x9B:
+ case 0x9C:
+ case 0x9D:
+ case 0x9E:
+ case 0x9F:
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF: goto yy74;
+ default: goto yy71;
+ }
+yy77:
+ YYDEBUG(77, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0x90:
+ case 0x91:
+ case 0x92:
+ case 0x93:
+ case 0x94:
+ case 0x95:
+ case 0x96:
+ case 0x97:
+ case 0x98:
+ case 0x99:
+ case 0x9A:
+ case 0x9B:
+ case 0x9C:
+ case 0x9D:
+ case 0x9E:
+ case 0x9F:
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF: goto yy76;
+ default: goto yy71;
+ }
+yy78:
+ YYDEBUG(78, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0x80:
+ case 0x81:
+ case 0x82:
+ case 0x83:
+ case 0x84:
+ case 0x85:
+ case 0x86:
+ case 0x87:
+ case 0x88:
+ case 0x89:
+ case 0x8A:
+ case 0x8B:
+ case 0x8C:
+ case 0x8D:
+ case 0x8E:
+ case 0x8F:
+ case 0x90:
+ case 0x91:
+ case 0x92:
+ case 0x93:
+ case 0x94:
+ case 0x95:
+ case 0x96:
+ case 0x97:
+ case 0x98:
+ case 0x99:
+ case 0x9A:
+ case 0x9B:
+ case 0x9C:
+ case 0x9D:
+ case 0x9E:
+ case 0x9F:
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF: goto yy76;
+ default: goto yy71;
+ }
+yy79:
+ YYDEBUG(79, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0x80:
+ case 0x81:
+ case 0x82:
+ case 0x83:
+ case 0x84:
+ case 0x85:
+ case 0x86:
+ case 0x87:
+ case 0x88:
+ case 0x89:
+ case 0x8A:
+ case 0x8B:
+ case 0x8C:
+ case 0x8D:
+ case 0x8E:
+ case 0x8F: goto yy76;
+ default: goto yy71;
+ }
+yy80:
+ YYDEBUG(80, YYPEEK ());
+ YYSKIP ();
+ YYDEBUG(81, YYPEEK ());
+#line 228 "wisitoken_grammar_1.re2c"
+ {*id = 11; skip_to(lexer, ")%"); continue;}
+#line 1930 "wisitoken_grammar_1_re2c.c"
+yy82:
+ YYDEBUG(82, YYPEEK ());
+ YYSKIP ();
+ YYDEBUG(83, YYPEEK ());
+#line 227 "wisitoken_grammar_1.re2c"
+ {*id = 10; skip_to(lexer, "]%"); continue;}
+#line 1937 "wisitoken_grammar_1_re2c.c"
+yy84:
+ YYDEBUG(84, YYPEEK ());
+ YYSKIP ();
+ YYDEBUG(85, YYPEEK ());
+#line 226 "wisitoken_grammar_1.re2c"
+ {*id = 9; skip_to(lexer, "}%"); continue;}
+#line 1944 "wisitoken_grammar_1_re2c.c"
+yy86:
+ YYDEBUG(86, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+yy87:
+ YYDEBUG(87, YYPEEK ());
+ switch (yych) {
+ case ' ':
+ case '!':
+ case '"':
+ case '#':
+ case '$':
+ case '%':
+ case '&':
+ case '(':
+ case ')':
+ case '*':
+ case '+':
+ case ',':
+ case '-':
+ case '.':
+ case '/':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case ':':
+ case ';':
+ case '<':
+ case '=':
+ case '>':
+ case '?':
+ case '@':
+ case 'A':
+ case 'B':
+ case 'C':
+ case 'D':
+ case 'E':
+ case 'F':
+ case 'G':
+ case 'H':
+ case 'I':
+ case 'J':
+ case 'K':
+ case 'L':
+ case 'M':
+ case 'N':
+ case 'O':
+ case 'P':
+ case 'Q':
+ case 'R':
+ case 'S':
+ case 'T':
+ case 'U':
+ case 'V':
+ case 'W':
+ case 'X':
+ case 'Y':
+ case 'Z':
+ case '[':
+ case '\\':
+ case ']':
+ case '^':
+ case '_':
+ case '`':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ case '{':
+ case '|':
+ case '}':
+ case '~':
+ case 0x7F: goto yy86;
+ case '\'': goto yy88;
+ case 0xC2:
+ case 0xC3:
+ case 0xC4:
+ case 0xC5:
+ case 0xC6:
+ case 0xC7:
+ case 0xC8:
+ case 0xC9:
+ case 0xCA:
+ case 0xCB:
+ case 0xCC:
+ case 0xCD:
+ case 0xCE:
+ case 0xCF:
+ case 0xD0:
+ case 0xD1:
+ case 0xD2:
+ case 0xD3:
+ case 0xD4:
+ case 0xD5:
+ case 0xD6:
+ case 0xD7:
+ case 0xD8:
+ case 0xD9:
+ case 0xDA:
+ case 0xDB:
+ case 0xDC:
+ case 0xDD:
+ case 0xDE:
+ case 0xDF: goto yy90;
+ case 0xE0: goto yy91;
+ case 0xE1:
+ case 0xE2:
+ case 0xE3:
+ case 0xE4:
+ case 0xE5:
+ case 0xE6:
+ case 0xE7:
+ case 0xE8:
+ case 0xE9:
+ case 0xEA:
+ case 0xEB:
+ case 0xEC:
+ case 0xED:
+ case 0xEE:
+ case 0xEF: goto yy92;
+ case 0xF0: goto yy93;
+ case 0xF1:
+ case 0xF2:
+ case 0xF3: goto yy94;
+ case 0xF4: goto yy95;
+ default: goto yy71;
+ }
+yy88:
+ YYDEBUG(88, YYPEEK ());
+ yyaccept = 4;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case '\'': goto yy86;
+ default: goto yy89;
+ }
+yy89:
+ YYDEBUG(89, YYPEEK ());
+#line 252 "wisitoken_grammar_1.re2c"
+ {*id = 35; continue;}
+#line 2115 "wisitoken_grammar_1_re2c.c"
+yy90:
+ YYDEBUG(90, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0x80:
+ case 0x81:
+ case 0x82:
+ case 0x83:
+ case 0x84:
+ case 0x85:
+ case 0x86:
+ case 0x87:
+ case 0x88:
+ case 0x89:
+ case 0x8A:
+ case 0x8B:
+ case 0x8C:
+ case 0x8D:
+ case 0x8E:
+ case 0x8F:
+ case 0x90:
+ case 0x91:
+ case 0x92:
+ case 0x93:
+ case 0x94:
+ case 0x95:
+ case 0x96:
+ case 0x97:
+ case 0x98:
+ case 0x99:
+ case 0x9A:
+ case 0x9B:
+ case 0x9C:
+ case 0x9D:
+ case 0x9E:
+ case 0x9F:
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF: goto yy86;
+ default: goto yy71;
+ }
+yy91:
+ YYDEBUG(91, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF: goto yy90;
+ default: goto yy71;
+ }
+yy92:
+ YYDEBUG(92, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0x80:
+ case 0x81:
+ case 0x82:
+ case 0x83:
+ case 0x84:
+ case 0x85:
+ case 0x86:
+ case 0x87:
+ case 0x88:
+ case 0x89:
+ case 0x8A:
+ case 0x8B:
+ case 0x8C:
+ case 0x8D:
+ case 0x8E:
+ case 0x8F:
+ case 0x90:
+ case 0x91:
+ case 0x92:
+ case 0x93:
+ case 0x94:
+ case 0x95:
+ case 0x96:
+ case 0x97:
+ case 0x98:
+ case 0x99:
+ case 0x9A:
+ case 0x9B:
+ case 0x9C:
+ case 0x9D:
+ case 0x9E:
+ case 0x9F:
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF: goto yy90;
+ default: goto yy71;
+ }
+yy93:
+ YYDEBUG(93, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0x90:
+ case 0x91:
+ case 0x92:
+ case 0x93:
+ case 0x94:
+ case 0x95:
+ case 0x96:
+ case 0x97:
+ case 0x98:
+ case 0x99:
+ case 0x9A:
+ case 0x9B:
+ case 0x9C:
+ case 0x9D:
+ case 0x9E:
+ case 0x9F:
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF: goto yy92;
+ default: goto yy71;
+ }
+yy94:
+ YYDEBUG(94, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0x80:
+ case 0x81:
+ case 0x82:
+ case 0x83:
+ case 0x84:
+ case 0x85:
+ case 0x86:
+ case 0x87:
+ case 0x88:
+ case 0x89:
+ case 0x8A:
+ case 0x8B:
+ case 0x8C:
+ case 0x8D:
+ case 0x8E:
+ case 0x8F:
+ case 0x90:
+ case 0x91:
+ case 0x92:
+ case 0x93:
+ case 0x94:
+ case 0x95:
+ case 0x96:
+ case 0x97:
+ case 0x98:
+ case 0x99:
+ case 0x9A:
+ case 0x9B:
+ case 0x9C:
+ case 0x9D:
+ case 0x9E:
+ case 0x9F:
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF: goto yy92;
+ default: goto yy71;
+ }
+yy95:
+ YYDEBUG(95, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0x80:
+ case 0x81:
+ case 0x82:
+ case 0x83:
+ case 0x84:
+ case 0x85:
+ case 0x86:
+ case 0x87:
+ case 0x88:
+ case 0x89:
+ case 0x8A:
+ case 0x8B:
+ case 0x8C:
+ case 0x8D:
+ case 0x8E:
+ case 0x8F: goto yy92;
+ default: goto yy71;
+ }
+yy96:
+ YYDEBUG(96, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case '=': goto yy113;
+ default: goto yy71;
+ }
+yy97:
+ YYDEBUG(97, YYPEEK ());
+ yyaccept = 5;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ YYDEBUG(98, YYPEEK ());
+ switch (yych) {
+ case 0x00:
+ case 0x01:
+ case 0x02:
+ case 0x03:
+ case 0x05:
+ case 0x06:
+ case 0x07:
+ case 0x08:
+ case '\t':
+ case '\v':
+ case '\f':
+ case '\r':
+ case 0x0E:
+ case 0x0F:
+ case 0x10:
+ case 0x11:
+ case 0x12:
+ case 0x13:
+ case 0x14:
+ case 0x15:
+ case 0x16:
+ case 0x17:
+ case 0x18:
+ case 0x19:
+ case 0x1A:
+ case 0x1B:
+ case 0x1C:
+ case 0x1D:
+ case 0x1E:
+ case 0x1F:
+ case ' ':
+ case '!':
+ case '"':
+ case '#':
+ case '$':
+ case '%':
+ case '&':
+ case '\'':
+ case '(':
+ case ')':
+ case '*':
+ case '+':
+ case ',':
+ case '-':
+ case '.':
+ case '/':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case ':':
+ case ';':
+ case '<':
+ case '=':
+ case '>':
+ case '?':
+ case '@':
+ case 'A':
+ case 'B':
+ case 'C':
+ case 'D':
+ case 'E':
+ case 'F':
+ case 'G':
+ case 'H':
+ case 'I':
+ case 'J':
+ case 'K':
+ case 'L':
+ case 'M':
+ case 'N':
+ case 'O':
+ case 'P':
+ case 'Q':
+ case 'R':
+ case 'S':
+ case 'T':
+ case 'U':
+ case 'V':
+ case 'W':
+ case 'X':
+ case 'Y':
+ case 'Z':
+ case '[':
+ case '\\':
+ case ']':
+ case '^':
+ case '_':
+ case '`':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ case '{':
+ case '|':
+ case '}':
+ case '~':
+ case 0x7F: goto yy97;
+ case 0xC2:
+ case 0xC3:
+ case 0xC4:
+ case 0xC5:
+ case 0xC6:
+ case 0xC7:
+ case 0xC8:
+ case 0xC9:
+ case 0xCA:
+ case 0xCB:
+ case 0xCC:
+ case 0xCD:
+ case 0xCE:
+ case 0xCF:
+ case 0xD0:
+ case 0xD1:
+ case 0xD2:
+ case 0xD3:
+ case 0xD4:
+ case 0xD5:
+ case 0xD6:
+ case 0xD7:
+ case 0xD8:
+ case 0xD9:
+ case 0xDA:
+ case 0xDB:
+ case 0xDC:
+ case 0xDD:
+ case 0xDE:
+ case 0xDF: goto yy115;
+ case 0xE0: goto yy116;
+ case 0xE1:
+ case 0xE2:
+ case 0xE3:
+ case 0xE4:
+ case 0xE5:
+ case 0xE6:
+ case 0xE7:
+ case 0xE8:
+ case 0xE9:
+ case 0xEA:
+ case 0xEB:
+ case 0xEC:
+ case 0xED:
+ case 0xEE:
+ case 0xEF: goto yy117;
+ case 0xF0: goto yy118;
+ case 0xF1:
+ case 0xF2:
+ case 0xF3: goto yy119;
+ case 0xF4: goto yy120;
+ default: goto yy99;
+ }
+yy99:
+ YYDEBUG(99, YYPEEK ());
+#line 219 "wisitoken_grammar_1.re2c"
+ {*id = 2; continue;}
+#line 2645 "wisitoken_grammar_1_re2c.c"
+yy100:
+ YYDEBUG(100, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0x80:
+ case 0x81:
+ case 0x82:
+ case 0x83:
+ case 0x84:
+ case 0x85:
+ case 0x86:
+ case 0x87:
+ case 0x88:
+ case 0x89:
+ case 0x8A:
+ case 0x8B:
+ case 0x8C:
+ case 0x8D:
+ case 0x8E:
+ case 0x8F:
+ case 0x90:
+ case 0x91:
+ case 0x92:
+ case 0x93:
+ case 0x94:
+ case 0x95:
+ case 0x96:
+ case 0x97:
+ case 0x98:
+ case 0x99:
+ case 0x9A:
+ case 0x9B:
+ case 0x9C:
+ case 0x9D:
+ case 0x9E:
+ case 0x9F:
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF: goto yy44;
+ default: goto yy71;
+ }
+yy101:
+ YYDEBUG(101, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF: goto yy100;
+ default: goto yy71;
+ }
+yy102:
+ YYDEBUG(102, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0x80:
+ case 0x81:
+ case 0x82:
+ case 0x83:
+ case 0x84:
+ case 0x85:
+ case 0x86:
+ case 0x87:
+ case 0x88:
+ case 0x89:
+ case 0x8A:
+ case 0x8B:
+ case 0x8C:
+ case 0x8D:
+ case 0x8E:
+ case 0x8F:
+ case 0x90:
+ case 0x91:
+ case 0x92:
+ case 0x93:
+ case 0x94:
+ case 0x95:
+ case 0x96:
+ case 0x97:
+ case 0x98:
+ case 0x99:
+ case 0x9A:
+ case 0x9B:
+ case 0x9C:
+ case 0x9D:
+ case 0x9E:
+ case 0x9F:
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF: goto yy100;
+ default: goto yy71;
+ }
+yy103:
+ YYDEBUG(103, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0x90:
+ case 0x91:
+ case 0x92:
+ case 0x93:
+ case 0x94:
+ case 0x95:
+ case 0x96:
+ case 0x97:
+ case 0x98:
+ case 0x99:
+ case 0x9A:
+ case 0x9B:
+ case 0x9C:
+ case 0x9D:
+ case 0x9E:
+ case 0x9F:
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF: goto yy102;
+ default: goto yy71;
+ }
+yy104:
+ YYDEBUG(104, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0x80:
+ case 0x81:
+ case 0x82:
+ case 0x83:
+ case 0x84:
+ case 0x85:
+ case 0x86:
+ case 0x87:
+ case 0x88:
+ case 0x89:
+ case 0x8A:
+ case 0x8B:
+ case 0x8C:
+ case 0x8D:
+ case 0x8E:
+ case 0x8F:
+ case 0x90:
+ case 0x91:
+ case 0x92:
+ case 0x93:
+ case 0x94:
+ case 0x95:
+ case 0x96:
+ case 0x97:
+ case 0x98:
+ case 0x99:
+ case 0x9A:
+ case 0x9B:
+ case 0x9C:
+ case 0x9D:
+ case 0x9E:
+ case 0x9F:
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF: goto yy102;
+ default: goto yy71;
+ }
+yy105:
+ YYDEBUG(105, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0x80:
+ case 0x81:
+ case 0x82:
+ case 0x83:
+ case 0x84:
+ case 0x85:
+ case 0x86:
+ case 0x87:
+ case 0x88:
+ case 0x89:
+ case 0x8A:
+ case 0x8B:
+ case 0x8C:
+ case 0x8D:
+ case 0x8E:
+ case 0x8F: goto yy102;
+ default: goto yy71;
+ }
+yy106:
+ YYDEBUG(106, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'd': goto yy121;
+ default: goto yy45;
+ }
+yy107:
+ YYDEBUG(107, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'd': goto yy122;
+ default: goto yy45;
+ }
+yy108:
+ YYDEBUG(108, YYPEEK ());
+ yyaccept = 6;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case '-':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case 'A':
+ case 'B':
+ case 'C':
+ case 'D':
+ case 'E':
+ case 'F':
+ case 'G':
+ case 'H':
+ case 'I':
+ case 'J':
+ case 'K':
+ case 'L':
+ case 'M':
+ case 'N':
+ case 'O':
+ case 'P':
+ case 'Q':
+ case 'R':
+ case 'S':
+ case 'T':
+ case 'U':
+ case 'V':
+ case 'W':
+ case 'X':
+ case 'Y':
+ case 'Z':
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ case 0xC2:
+ case 0xC3:
+ case 0xC4:
+ case 0xC5:
+ case 0xC6:
+ case 0xC7:
+ case 0xC8:
+ case 0xC9:
+ case 0xCA:
+ case 0xCB:
+ case 0xCC:
+ case 0xCD:
+ case 0xCE:
+ case 0xCF:
+ case 0xD0:
+ case 0xD1:
+ case 0xD2:
+ case 0xD3:
+ case 0xD4:
+ case 0xD5:
+ case 0xD6:
+ case 0xD7:
+ case 0xD8:
+ case 0xD9:
+ case 0xDA:
+ case 0xDB:
+ case 0xDC:
+ case 0xDD:
+ case 0xDE:
+ case 0xDF:
+ case 0xE0:
+ case 0xE1:
+ case 0xE2:
+ case 0xE3:
+ case 0xE4:
+ case 0xE5:
+ case 0xE6:
+ case 0xE7:
+ case 0xE8:
+ case 0xE9:
+ case 0xEA:
+ case 0xEB:
+ case 0xEC:
+ case 0xED:
+ case 0xEE:
+ case 0xEF:
+ case 0xF0:
+ case 0xF1:
+ case 0xF2:
+ case 0xF3:
+ case 0xF4: goto yy45;
+ default: goto yy109;
+ }
+yy109:
+ YYDEBUG(109, YYPEEK ());
+#line 222 "wisitoken_grammar_1.re2c"
+ {*id = 5; continue;}
+#line 3124 "wisitoken_grammar_1_re2c.c"
+yy110:
+ YYDEBUG(110, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'y': goto yy124;
+ default: goto yy45;
+ }
+yy111:
+ YYDEBUG(111, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'n': goto yy125;
+ default: goto yy45;
+ }
+yy112:
+ YYDEBUG(112, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'k': goto yy126;
+ default: goto yy45;
+ }
+yy113:
+ YYDEBUG(113, YYPEEK ());
+ YYSKIP ();
+ YYDEBUG(114, YYPEEK ());
+#line 231 "wisitoken_grammar_1.re2c"
+ {*id = 14; continue;}
+#line 3161 "wisitoken_grammar_1_re2c.c"
+yy115:
+ YYDEBUG(115, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0x80:
+ case 0x81:
+ case 0x82:
+ case 0x83:
+ case 0x84:
+ case 0x85:
+ case 0x86:
+ case 0x87:
+ case 0x88:
+ case 0x89:
+ case 0x8A:
+ case 0x8B:
+ case 0x8C:
+ case 0x8D:
+ case 0x8E:
+ case 0x8F:
+ case 0x90:
+ case 0x91:
+ case 0x92:
+ case 0x93:
+ case 0x94:
+ case 0x95:
+ case 0x96:
+ case 0x97:
+ case 0x98:
+ case 0x99:
+ case 0x9A:
+ case 0x9B:
+ case 0x9C:
+ case 0x9D:
+ case 0x9E:
+ case 0x9F:
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF: goto yy97;
+ default: goto yy71;
+ }
+yy116:
+ YYDEBUG(116, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF: goto yy115;
+ default: goto yy71;
+ }
+yy117:
+ YYDEBUG(117, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0x80:
+ case 0x81:
+ case 0x82:
+ case 0x83:
+ case 0x84:
+ case 0x85:
+ case 0x86:
+ case 0x87:
+ case 0x88:
+ case 0x89:
+ case 0x8A:
+ case 0x8B:
+ case 0x8C:
+ case 0x8D:
+ case 0x8E:
+ case 0x8F:
+ case 0x90:
+ case 0x91:
+ case 0x92:
+ case 0x93:
+ case 0x94:
+ case 0x95:
+ case 0x96:
+ case 0x97:
+ case 0x98:
+ case 0x99:
+ case 0x9A:
+ case 0x9B:
+ case 0x9C:
+ case 0x9D:
+ case 0x9E:
+ case 0x9F:
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF: goto yy115;
+ default: goto yy71;
+ }
+yy118:
+ YYDEBUG(118, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0x90:
+ case 0x91:
+ case 0x92:
+ case 0x93:
+ case 0x94:
+ case 0x95:
+ case 0x96:
+ case 0x97:
+ case 0x98:
+ case 0x99:
+ case 0x9A:
+ case 0x9B:
+ case 0x9C:
+ case 0x9D:
+ case 0x9E:
+ case 0x9F:
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF: goto yy117;
+ default: goto yy71;
+ }
+yy119:
+ YYDEBUG(119, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0x80:
+ case 0x81:
+ case 0x82:
+ case 0x83:
+ case 0x84:
+ case 0x85:
+ case 0x86:
+ case 0x87:
+ case 0x88:
+ case 0x89:
+ case 0x8A:
+ case 0x8B:
+ case 0x8C:
+ case 0x8D:
+ case 0x8E:
+ case 0x8F:
+ case 0x90:
+ case 0x91:
+ case 0x92:
+ case 0x93:
+ case 0x94:
+ case 0x95:
+ case 0x96:
+ case 0x97:
+ case 0x98:
+ case 0x99:
+ case 0x9A:
+ case 0x9B:
+ case 0x9C:
+ case 0x9D:
+ case 0x9E:
+ case 0x9F:
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF: goto yy117;
+ default: goto yy71;
+ }
+yy120:
+ YYDEBUG(120, YYPEEK ());
+ YYSKIP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 0x80:
+ case 0x81:
+ case 0x82:
+ case 0x83:
+ case 0x84:
+ case 0x85:
+ case 0x86:
+ case 0x87:
+ case 0x88:
+ case 0x89:
+ case 0x8A:
+ case 0x8B:
+ case 0x8C:
+ case 0x8D:
+ case 0x8E:
+ case 0x8F: goto yy117;
+ default: goto yy71;
+ }
+yy121:
+ YYDEBUG(121, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'e': goto yy127;
+ default: goto yy45;
+ }
+yy122:
+ YYDEBUG(122, YYPEEK ());
+ yyaccept = 7;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case '-':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case 'A':
+ case 'B':
+ case 'C':
+ case 'D':
+ case 'E':
+ case 'F':
+ case 'G':
+ case 'H':
+ case 'I':
+ case 'J':
+ case 'K':
+ case 'L':
+ case 'M':
+ case 'N':
+ case 'O':
+ case 'P':
+ case 'Q':
+ case 'R':
+ case 'S':
+ case 'T':
+ case 'U':
+ case 'V':
+ case 'W':
+ case 'X':
+ case 'Y':
+ case 'Z':
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ case 0xC2:
+ case 0xC3:
+ case 0xC4:
+ case 0xC5:
+ case 0xC6:
+ case 0xC7:
+ case 0xC8:
+ case 0xC9:
+ case 0xCA:
+ case 0xCB:
+ case 0xCC:
+ case 0xCD:
+ case 0xCE:
+ case 0xCF:
+ case 0xD0:
+ case 0xD1:
+ case 0xD2:
+ case 0xD3:
+ case 0xD4:
+ case 0xD5:
+ case 0xD6:
+ case 0xD7:
+ case 0xD8:
+ case 0xD9:
+ case 0xDA:
+ case 0xDB:
+ case 0xDC:
+ case 0xDD:
+ case 0xDE:
+ case 0xDF:
+ case 0xE0:
+ case 0xE1:
+ case 0xE2:
+ case 0xE3:
+ case 0xE4:
+ case 0xE5:
+ case 0xE6:
+ case 0xE7:
+ case 0xE8:
+ case 0xE9:
+ case 0xEA:
+ case 0xEB:
+ case 0xEC:
+ case 0xED:
+ case 0xEE:
+ case 0xEF:
+ case 0xF0:
+ case 0xF1:
+ case 0xF2:
+ case 0xF3:
+ case 0xF4: goto yy45;
+ default: goto yy123;
+ }
+yy123:
+ YYDEBUG(123, YYPEEK ());
+#line 221 "wisitoken_grammar_1.re2c"
+ {*id = 4; continue;}
+#line 3630 "wisitoken_grammar_1_re2c.c"
+yy124:
+ YYDEBUG(124, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'w': goto yy129;
+ default: goto yy45;
+ }
+yy125:
+ YYDEBUG(125, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case '_': goto yy130;
+ default: goto yy45;
+ }
+yy126:
+ YYDEBUG(126, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'e': goto yy131;
+ default: goto yy45;
+ }
+yy127:
+ YYDEBUG(127, YYPEEK ());
+ yyaccept = 8;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case '-':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case 'A':
+ case 'B':
+ case 'C':
+ case 'D':
+ case 'E':
+ case 'F':
+ case 'G':
+ case 'H':
+ case 'I':
+ case 'J':
+ case 'K':
+ case 'L':
+ case 'M':
+ case 'N':
+ case 'O':
+ case 'P':
+ case 'Q':
+ case 'R':
+ case 'S':
+ case 'T':
+ case 'U':
+ case 'V':
+ case 'W':
+ case 'X':
+ case 'Y':
+ case 'Z':
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ case 0xC2:
+ case 0xC3:
+ case 0xC4:
+ case 0xC5:
+ case 0xC6:
+ case 0xC7:
+ case 0xC8:
+ case 0xC9:
+ case 0xCA:
+ case 0xCB:
+ case 0xCC:
+ case 0xCD:
+ case 0xCE:
+ case 0xCF:
+ case 0xD0:
+ case 0xD1:
+ case 0xD2:
+ case 0xD3:
+ case 0xD4:
+ case 0xD5:
+ case 0xD6:
+ case 0xD7:
+ case 0xD8:
+ case 0xD9:
+ case 0xDA:
+ case 0xDB:
+ case 0xDC:
+ case 0xDD:
+ case 0xDE:
+ case 0xDF:
+ case 0xE0:
+ case 0xE1:
+ case 0xE2:
+ case 0xE3:
+ case 0xE4:
+ case 0xE5:
+ case 0xE6:
+ case 0xE7:
+ case 0xE8:
+ case 0xE9:
+ case 0xEA:
+ case 0xEB:
+ case 0xEC:
+ case 0xED:
+ case 0xEE:
+ case 0xEF:
+ case 0xF0:
+ case 0xF1:
+ case 0xF2:
+ case 0xF3:
+ case 0xF4: goto yy45;
+ default: goto yy128;
+ }
+yy128:
+ YYDEBUG(128, YYPEEK ());
+#line 220 "wisitoken_grammar_1.re2c"
+ {*id = 3; continue;}
+#line 3789 "wisitoken_grammar_1_re2c.c"
+yy129:
+ YYDEBUG(129, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'o': goto yy132;
+ default: goto yy45;
+ }
+yy130:
+ YYDEBUG(130, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'g': goto yy133;
+ default: goto yy45;
+ }
+yy131:
+ YYDEBUG(131, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'n': goto yy134;
+ default: goto yy45;
+ }
+yy132:
+ YYDEBUG(132, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'r': goto yy136;
+ default: goto yy45;
+ }
+yy133:
+ YYDEBUG(133, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'r': goto yy137;
+ default: goto yy45;
+ }
+yy134:
+ YYDEBUG(134, YYPEEK ());
+ yyaccept = 9;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case '-':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case 'A':
+ case 'B':
+ case 'C':
+ case 'D':
+ case 'E':
+ case 'F':
+ case 'G':
+ case 'H':
+ case 'I':
+ case 'J':
+ case 'K':
+ case 'L':
+ case 'M':
+ case 'N':
+ case 'O':
+ case 'P':
+ case 'Q':
+ case 'R':
+ case 'S':
+ case 'T':
+ case 'U':
+ case 'V':
+ case 'W':
+ case 'X':
+ case 'Y':
+ case 'Z':
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ case 0xC2:
+ case 0xC3:
+ case 0xC4:
+ case 0xC5:
+ case 0xC6:
+ case 0xC7:
+ case 0xC8:
+ case 0xC9:
+ case 0xCA:
+ case 0xCB:
+ case 0xCC:
+ case 0xCD:
+ case 0xCE:
+ case 0xCF:
+ case 0xD0:
+ case 0xD1:
+ case 0xD2:
+ case 0xD3:
+ case 0xD4:
+ case 0xD5:
+ case 0xD6:
+ case 0xD7:
+ case 0xD8:
+ case 0xD9:
+ case 0xDA:
+ case 0xDB:
+ case 0xDC:
+ case 0xDD:
+ case 0xDE:
+ case 0xDF:
+ case 0xE0:
+ case 0xE1:
+ case 0xE2:
+ case 0xE3:
+ case 0xE4:
+ case 0xE5:
+ case 0xE6:
+ case 0xE7:
+ case 0xE8:
+ case 0xE9:
+ case 0xEA:
+ case 0xEB:
+ case 0xEC:
+ case 0xED:
+ case 0xEE:
+ case 0xEF:
+ case 0xF0:
+ case 0xF1:
+ case 0xF2:
+ case 0xF3:
+ case 0xF4: goto yy45;
+ default: goto yy135;
+ }
+yy135:
+ YYDEBUG(135, YYPEEK ());
+#line 225 "wisitoken_grammar_1.re2c"
+ {*id = 8; continue;}
+#line 3968 "wisitoken_grammar_1_re2c.c"
+yy136:
+ YYDEBUG(136, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'd': goto yy138;
+ default: goto yy45;
+ }
+yy137:
+ YYDEBUG(137, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'a': goto yy140;
+ default: goto yy45;
+ }
+yy138:
+ YYDEBUG(138, YYPEEK ());
+ yyaccept = 10;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case '-':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case 'A':
+ case 'B':
+ case 'C':
+ case 'D':
+ case 'E':
+ case 'F':
+ case 'G':
+ case 'H':
+ case 'I':
+ case 'J':
+ case 'K':
+ case 'L':
+ case 'M':
+ case 'N':
+ case 'O':
+ case 'P':
+ case 'Q':
+ case 'R':
+ case 'S':
+ case 'T':
+ case 'U':
+ case 'V':
+ case 'W':
+ case 'X':
+ case 'Y':
+ case 'Z':
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ case 0xC2:
+ case 0xC3:
+ case 0xC4:
+ case 0xC5:
+ case 0xC6:
+ case 0xC7:
+ case 0xC8:
+ case 0xC9:
+ case 0xCA:
+ case 0xCB:
+ case 0xCC:
+ case 0xCD:
+ case 0xCE:
+ case 0xCF:
+ case 0xD0:
+ case 0xD1:
+ case 0xD2:
+ case 0xD3:
+ case 0xD4:
+ case 0xD5:
+ case 0xD6:
+ case 0xD7:
+ case 0xD8:
+ case 0xD9:
+ case 0xDA:
+ case 0xDB:
+ case 0xDC:
+ case 0xDD:
+ case 0xDE:
+ case 0xDF:
+ case 0xE0:
+ case 0xE1:
+ case 0xE2:
+ case 0xE3:
+ case 0xE4:
+ case 0xE5:
+ case 0xE6:
+ case 0xE7:
+ case 0xE8:
+ case 0xE9:
+ case 0xEA:
+ case 0xEB:
+ case 0xEC:
+ case 0xED:
+ case 0xEE:
+ case 0xEF:
+ case 0xF0:
+ case 0xF1:
+ case 0xF2:
+ case 0xF3:
+ case 0xF4: goto yy45;
+ default: goto yy139;
+ }
+yy139:
+ YYDEBUG(139, YYPEEK ());
+#line 223 "wisitoken_grammar_1.re2c"
+ {*id = 6; continue;}
+#line 4117 "wisitoken_grammar_1_re2c.c"
+yy140:
+ YYDEBUG(140, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'm': goto yy141;
+ default: goto yy45;
+ }
+yy141:
+ YYDEBUG(141, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'm': goto yy142;
+ default: goto yy45;
+ }
+yy142:
+ YYDEBUG(142, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'a': goto yy143;
+ default: goto yy45;
+ }
+yy143:
+ YYDEBUG(143, YYPEEK ());
+ yyaccept = 2;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case 'r': goto yy144;
+ default: goto yy45;
+ }
+yy144:
+ YYDEBUG(144, YYPEEK ());
+ yyaccept = 11;
+ YYSKIP ();
+ YYBACKUP ();
+ yych = YYPEEK ();
+ switch (yych) {
+ case '-':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case 'A':
+ case 'B':
+ case 'C':
+ case 'D':
+ case 'E':
+ case 'F':
+ case 'G':
+ case 'H':
+ case 'I':
+ case 'J':
+ case 'K':
+ case 'L':
+ case 'M':
+ case 'N':
+ case 'O':
+ case 'P':
+ case 'Q':
+ case 'R':
+ case 'S':
+ case 'T':
+ case 'U':
+ case 'V':
+ case 'W':
+ case 'X':
+ case 'Y':
+ case 'Z':
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ case 0xC2:
+ case 0xC3:
+ case 0xC4:
+ case 0xC5:
+ case 0xC6:
+ case 0xC7:
+ case 0xC8:
+ case 0xC9:
+ case 0xCA:
+ case 0xCB:
+ case 0xCC:
+ case 0xCD:
+ case 0xCE:
+ case 0xCF:
+ case 0xD0:
+ case 0xD1:
+ case 0xD2:
+ case 0xD3:
+ case 0xD4:
+ case 0xD5:
+ case 0xD6:
+ case 0xD7:
+ case 0xD8:
+ case 0xD9:
+ case 0xDA:
+ case 0xDB:
+ case 0xDC:
+ case 0xDD:
+ case 0xDE:
+ case 0xDF:
+ case 0xE0:
+ case 0xE1:
+ case 0xE2:
+ case 0xE3:
+ case 0xE4:
+ case 0xE5:
+ case 0xE6:
+ case 0xE7:
+ case 0xE8:
+ case 0xE9:
+ case 0xEA:
+ case 0xEB:
+ case 0xEC:
+ case 0xED:
+ case 0xEE:
+ case 0xEF:
+ case 0xF0:
+ case 0xF1:
+ case 0xF2:
+ case 0xF3:
+ case 0xF4: goto yy45;
+ default: goto yy145;
+ }
+yy145:
+ YYDEBUG(145, YYPEEK ());
+#line 224 "wisitoken_grammar_1.re2c"
+ {*id = 7; continue;}
+#line 4286 "wisitoken_grammar_1_re2c.c"
+}
+#line 256 "wisitoken_grammar_1.re2c"
+
+ }
+ *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;
+ return status;
+ }
diff --git a/wisitoken_grammar_1_re2c_c.ads b/wisitoken_grammar_1_re2c_c.ads
new file mode 100644
index 0000000..3c51528
--- /dev/null
+++ b/wisitoken_grammar_1_re2c_c.ads
@@ -0,0 +1,63 @@
+-- generated parser support file.
+-- command line: wisitoken-bnf-generate.exe --generate LR1 Ada_Emacs re2c
PROCESS wisitoken_grammar_1.wy
+--
+
+-- 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/>.
+
+with Interfaces.C;
+with WisiToken;
+with System;
+package wisitoken_grammar_1_re2c_c is
+
+ function New_Lexer
+ (Buffer : in System.Address;
+ Length : in Interfaces.C.size_t;
+ Verbosity : in Interfaces.C.int)
+ return System.Address
+ with Import => True,
+ Convention => C,
+ External_Name => "wisitoken_grammar_1_new_lexer";
+ -- Create the lexer object, passing it the full text to process.
+
+ procedure Free_Lexer (Lexer : in out System.Address)
+ with Import => True,
+ Convention => C,
+ External_Name => "wisitoken_grammar_1_free_lexer";
+ -- Free the lexer object
+
+ procedure Reset_Lexer (Lexer : in System.Address)
+ with Import => True,
+ Convention => C,
+ External_Name => "wisitoken_grammar_1_reset_lexer";
+
+ function Next_Token
+ (Lexer : in System.Address;
+ ID : out WisiToken.Token_ID;
+ Byte_Position : out Interfaces.C.size_t;
+ Byte_Length : out Interfaces.C.size_t;
+ Char_Position : out Interfaces.C.size_t;
+ Char_Length : out Interfaces.C.size_t;
+ Line_Start : out Interfaces.C.int)
+ return Interfaces.C.int
+ with Import => True,
+ Convention => C,
+ External_Name => "wisitoken_grammar_1_next_token";
+
+end wisitoken_grammar_1_re2c_c;
diff --git a/wisitoken_grammar_mode_parse.ads b/wisitoken_grammar_mode_parse.ads
new file mode 100644
index 0000000..f8015fa
--- /dev/null
+++ b/wisitoken_grammar_mode_parse.ads
@@ -0,0 +1,34 @@
+-- Abstract :
+--
+-- External process parser for wisitoken-grammar mode
+--
+-- Copyright (C) 2017 - 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 Wisitoken_Grammar_1_Process_Actions;
+with Wisitoken_Grammar_1_Process_Main;
+with Gen_Emacs_Wisi_LR_Parse;
+with Wisi.WisiToken_Grammar;
+procedure WisiToken_Grammar_Mode_Parse is new Gen_Emacs_Wisi_LR_Parse
+ (Parse_Data_Type => Wisi.WisiToken_Grammar.Parse_Data_Type,
+ Name => "wisi_grammar_mode",
+ Language_Protocol_Version =>
Wisi.WisiToken_Grammar.Language_Protocol_Version,
+ Descriptor =>
Wisitoken_Grammar_1_Process_Actions.Descriptor,
+ Partial_Parse_Active =>
Wisitoken_Grammar_1_Process_Actions.Partial_Parse_Active,
+ Language_Fixes => null,
+ Language_Matching_Begin_Tokens => null,
+ Language_String_ID_Set => null,
+ Create_Parser =>
Wisitoken_Grammar_1_Process_Main.Create_Parser);