[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[elpa] externals-release/gpr-mode 1932e3a42c: Add files to gpr-mode
|
From: |
Stephen Leake |
|
Subject: |
[elpa] externals-release/gpr-mode 1932e3a42c: Add files to gpr-mode |
|
Date: |
Tue, 1 Nov 2022 16:35:40 -0400 (EDT) |
branch: externals-release/gpr-mode
commit 1932e3a42cf5cf2b4ea0ac0b8137556f7e656238
Author: Stephen Leake <stephen_leake@stephe-leake.org>
Commit: Stephen Leake <stephen_leake@stephe-leake.org>
Add files to gpr-mode
---
Alire.make | 9 +
ELPA.make | 51 +
NEWS | 13 +
README | 25 +
build.sh | 41 +
doclicense.texi | 507 +++
emacs_gpr_mode.gpr | 33 +
gpr-indent-user-options.el | 48 +
gpr-mode.el | 432 +++
gpr-mode.texi | 256 ++
gpr-process.el | 148 +
gpr-skel.el | 137 +
gpr.wy | 379 +++
gpr_mode_wisi_parse.ads | 31 +
gpr_mode_wisi_parse.gpr | 91 +
gpr_process_actions.adb | 418 +++
gpr_process_actions.ads | 304 ++
gpr_process_main.adb | 2640 +++++++++++++++
gpr_process_main.ads | 32 +
gpr_re2c.c | 7693 ++++++++++++++++++++++++++++++++++++++++++++
gpr_re2c_c.ads | 74 +
install.sh | 35 +
prj-eglot.el | 40 +
run_gpr_parse.ads | 29 +
run_gpr_parse.exe | Bin 0 -> 11834278 bytes
wisi-gpr.adb | 84 +
wisi-gpr.ads | 56 +
27 files changed, 13606 insertions(+)
diff --git a/Alire.make b/Alire.make
new file mode 100644
index 0000000000..8e9a50bbcb
--- /dev/null
+++ b/Alire.make
@@ -0,0 +1,9 @@
+# For compiling gpr-mode Ada code with Alire
+
+STEPHES_ADA_LIBRARY_ALIRE_PREFIX ?= $(CURDIR)/../org.stephe_leake.sal
+
+include $(STEPHES_ADA_LIBRARY_ALIRE_PREFIX)/build/alire_rules.make
+
+# Local Variables:
+# eval: (load-file "prj-eglot.el")
+# End:
diff --git a/ELPA.make b/ELPA.make
new file mode 100644
index 0000000000..5e6de64bc9
--- /dev/null
+++ b/ELPA.make
@@ -0,0 +1,51 @@
+# For compiling ada-mode Ada code in elpa worktree
+
+#export Standard_Common_Build := Debug
+
+.PHONY : all force
+
+all : build_executables byte-compile
+
+Makefile.conf : create_makefile_conf.sh
+ $(SHELL) -c ./create_makefile_conf.sh
+
+include Makefile.conf
+
+build_executables : ada_mode_wisi_parse.gpr gpr_re2c.c ada_annex_p_re2c.c force
+ gprbuild -p -j8 ada_mode_wisi_parse.gpr
+
+../wisi/wisi.gpr : ../wisi/wisi.gpr.gp
+ gnatprep -DELPA="yes" ../wisi/wisi.gpr.gp ../wisi/wisi.gpr
+
+ada_mode_wisi_parse.gpr : ada_mode_wisi_parse.gpr.gp ../wisi/wisi.gpr
+ gnatprep -DELPA="yes" -DHAVE_GNAT_UTIL=$(HAVE_GNAT_UTIL)
-DHAVE_LIBADALANG=$(HAVE_LIBADALANG) $< $@
+
+%.re2c : %.wy ../wisi/wisitoken-bnf-generate
+ ../wisi/wisitoken-bnf-generate $(<F)
+ dos2unix -q $(*F)-process.el $(*F)_process* $(*F).re2c $(*F)_re2c_c.ads
+
+%_re2c.c : %.re2c
+ re2c --no-generation-date --debug-output --input custom -W -Werror
--utf-8 -o $@ $<
+ dos2unix -q $(*F)_re2c.c
+
+../wisi/wisitoken-bnf-generate : ../wisi/wisi.gpr force
+ cd ../wisi; gprbuild -p -j8 -P wisi.gpr wisitoken-bnf-generate
+
+BYTE_COMPILE := "(progn (setq package-load-list '((wisi) (ada-mode) all))
(package-initialize)(setq byte-compile-error-on-warn t)(batch-byte-compile))"
+byte-compile : byte-compile-clean
+ cd ../wisi; emacs -Q -batch -L . --eval $(BYTE_COMPILE) *.el
+ emacs -Q -batch -L . -L ../wisi --eval $(BYTE_COMPILE) *.el
+
+byte-compile-clean :
+ cd ..; rm -f *.elc
+
+clean : force
+ rm -rf obj *parse_table*
+
+recursive-clean : force
+ gprclean -r -P ada_mode_wisi_parse.gpr
+
+# Local Variables:
+# eval: (load-file "prj.el")
+# End:
+# end of file
diff --git a/NEWS b/NEWS
new file mode 100644
index 0000000000..de1d7a973c
--- /dev/null
+++ b/NEWS
@@ -0,0 +1,13 @@
+GNU Emacs gpr mode NEWS -- history of user-visible changes.
+
+Copyright (C) 2022 Free Software Foundation, Inc.
+
+Please send gpr-mode bug reports to bug-gnu-emacs@gnu.org, with
+'gpr-mode' in the subject. If possible, use M-x report-emacs-bug.
+
+
+* gpr mode 1.0.1
+
+** Split out from ada-mode
+
+** language protocol version 1
diff --git a/README b/README
new file mode 100644
index 0000000000..49cbf0f326
--- /dev/null
+++ b/README
@@ -0,0 +1,25 @@
+Emacs gpr mode version 1.0.1
+
+gpr mode provides auto-casing, fontification, navigation, and
+indentation for gpr source code files.
+
+gpr mode uses a parser to provide fontification, navigation, and
+indentation.
+
+The parser is provided as Ada source code that must be compiled and
+installed:
+
+cd ~/.emacs.d/elpa/gpr-mode-i.j.k
+./build.sh
+./install.sh
+
+install.sh can take an option "--prefix=<dir>" to set the installation
+directory.
+
+gpr mode will be automatically loaded when you open a file
+with a matching extension (default *.gpr).
+
+gpr mode uses wisi project files to define large (multi-directory)
+projects, and to define casing exceptions.
+
+See gpr-mode.info for help on using and customizing gpr mode.
diff --git a/build.sh b/build.sh
new file mode 100644
index 0000000000..5348c5b3a2
--- /dev/null
+++ b/build.sh
@@ -0,0 +1,41 @@
+#!/bin/sh
+# Build executables for gpr mode.
+# build.sh <other gprbuild options>
+# e.g. 'build.sh -j0' : use all available processors to compile
+# 'build.sh -wn' : treat warnings as warnings.
+# 'build.sh -vh' : Verbose output (high verbosity)
+#
+# See install.sh for install
+
+if type alr; then
+ echo "building gpr-mode executables via Alire"
+ alr get emacs_gpr_mode~1.0.1
+ cd emacs_gpr_mode_*; alr build --release
+
+elif type gprbuild; then
+ echo "building gpr-mode executables via gnat compiler"
+
+ if [ -d ../wisi-4.1.? ]; then
+ WISI_DIR=`ls -d ../wisi-4.1.?`
+ fi
+
+ args=`echo -DELPA="yes" $WISI_DIR/wisi.gpr.gp $WISI_DIR/wisi.gpr`
+ echo "gnatprep " $args
+ gnatprep $args
+
+ # We don't add WISI_DIR to GPR_PROJECT_PATH because the user may have
+ # already set GPR_PROJECT_PATH.
+
+ # Allow running build.sh again, since it often fails the first time.
+ # - Run gprclean, to allow changing compilers and other drastic things
+
+ gprclean -r -P gpr_mode_wisi_parse.gpr -aP$WISI_DIR
+
+ gprbuild -p -j8 -P gpr_mode_wisi_parse.gpr -aP $WISI_DIR "$@"
+
+else
+ echo "neither Alire nor gnat compiler found"
+ return 1
+fi
+
+# end of file
diff --git a/doclicense.texi b/doclicense.texi
new file mode 100644
index 0000000000..a511ffcd5a
--- /dev/null
+++ b/doclicense.texi
@@ -0,0 +1,507 @@
+@c -*-texinfo-*-
+@c The GNU Free Documentation License.
+@center Version 1.3, 3 November 2008
+
+@c This file is intended to be included within another document,
+@c hence no sectioning command or @node.
+
+@display
+Copyright @copyright{} 2000, 2001, 2002, 2007, 2008, 2009 Free Software
Foundation, Inc.
+@uref{http://fsf.org/}
+
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.
+@end display
+
+@enumerate 0
+@item
+PREAMBLE
+
+The purpose of this License is to make a manual, textbook, or other
+functional and useful document @dfn{free} in the sense of freedom: to
+assure everyone the effective freedom to copy and redistribute it,
+with or without modifying it, either commercially or noncommercially.
+Secondarily, this License preserves for the author and publisher a way
+to get credit for their work, while not being considered responsible
+for modifications made by others.
+
+This License is a kind of ``copyleft'', which means that derivative
+works of the document must themselves be free in the same sense. It
+complements the GNU General Public License, which is a copyleft
+license designed for free software.
+
+We have designed this License in order to use it for manuals for free
+software, because free software needs free documentation: a free
+program should come with manuals providing the same freedoms that the
+software does. But this License is not limited to software manuals;
+it can be used for any textual work, regardless of subject matter or
+whether it is published as a printed book. We recommend this License
+principally for works whose purpose is instruction or reference.
+
+@item
+APPLICABILITY AND DEFINITIONS
+
+This License applies to any manual or other work, in any medium, that
+contains a notice placed by the copyright holder saying it can be
+distributed under the terms of this License. Such a notice grants a
+world-wide, royalty-free license, unlimited in duration, to use that
+work under the conditions stated herein. The ``Document'', below,
+refers to any such manual or work. Any member of the public is a
+licensee, and is addressed as ``you''. You accept the license if you
+copy, modify or distribute the work in a way requiring permission
+under copyright law.
+
+A ``Modified Version'' of the Document means any work containing the
+Document or a portion of it, either copied verbatim, or with
+modifications and/or translated into another language.
+
+A ``Secondary Section'' is a named appendix or a front-matter section
+of the Document that deals exclusively with the relationship of the
+publishers or authors of the Document to the Document's overall
+subject (or to related matters) and contains nothing that could fall
+directly within that overall subject. (Thus, if the Document is in
+part a textbook of mathematics, a Secondary Section may not explain
+any mathematics.) The relationship could be a matter of historical
+connection with the subject or with related matters, or of legal,
+commercial, philosophical, ethical or political position regarding
+them.
+
+The ``Invariant Sections'' are certain Secondary Sections whose titles
+are designated, as being those of Invariant Sections, in the notice
+that says that the Document is released under this License. If a
+section does not fit the above definition of Secondary then it is not
+allowed to be designated as Invariant. The Document may contain zero
+Invariant Sections. If the Document does not identify any Invariant
+Sections then there are none.
+
+The ``Cover Texts'' are certain short passages of text that are listed,
+as Front-Cover Texts or Back-Cover Texts, in the notice that says that
+the Document is released under this License. A Front-Cover Text may
+be at most 5 words, and a Back-Cover Text may be at most 25 words.
+
+A ``Transparent'' copy of the Document means a machine-readable copy,
+represented in a format whose specification is available to the
+general public, that is suitable for revising the document
+straightforwardly with generic text editors or (for images composed of
+pixels) generic paint programs or (for drawings) some widely available
+drawing editor, and that is suitable for input to text formatters or
+for automatic translation to a variety of formats suitable for input
+to text formatters. A copy made in an otherwise Transparent file
+format whose markup, or absence of markup, has been arranged to thwart
+or discourage subsequent modification by readers is not Transparent.
+An image format is not Transparent if used for any substantial amount
+of text. A copy that is not ``Transparent'' is called ``Opaque''.
+
+Examples of suitable formats for Transparent copies include plain
+@sc{ascii} without markup, Texinfo input format, La@TeX{} input
+format, @acronym{SGML} or @acronym{XML} using a publicly available
+@acronym{DTD}, and standard-conforming simple @acronym{HTML},
+PostScript or @acronym{PDF} designed for human modification. Examples
+of transparent image formats include @acronym{PNG}, @acronym{XCF} and
+@acronym{JPG}. Opaque formats include proprietary formats that can be
+read and edited only by proprietary word processors, @acronym{SGML} or
+@acronym{XML} for which the @acronym{DTD} and/or processing tools are
+not generally available, and the machine-generated @acronym{HTML},
+PostScript or @acronym{PDF} produced by some word processors for
+output purposes only.
+
+The ``Title Page'' means, for a printed book, the title page itself,
+plus such following pages as are needed to hold, legibly, the material
+this License requires to appear in the title page. For works in
+formats which do not have any title page as such, ``Title Page'' means
+the text near the most prominent appearance of the work's title,
+preceding the beginning of the body of the text.
+
+The ``publisher'' means any person or entity that distributes copies
+of the Document to the public.
+
+A section ``Entitled XYZ'' means a named subunit of the Document whose
+title either is precisely XYZ or contains XYZ in parentheses following
+text that translates XYZ in another language. (Here XYZ stands for a
+specific section name mentioned below, such as ``Acknowledgements'',
+``Dedications'', ``Endorsements'', or ``History''.) To ``Preserve the Title''
+of such a section when you modify the Document means that it remains a
+section ``Entitled XYZ'' according to this definition.
+
+The Document may include Warranty Disclaimers next to the notice which
+states that this License applies to the Document. These Warranty
+Disclaimers are considered to be included by reference in this
+License, but only as regards disclaiming warranties: any other
+implication that these Warranty Disclaimers may have is void and has
+no effect on the meaning of this License.
+
+@item
+VERBATIM COPYING
+
+You may copy and distribute the Document in any medium, either
+commercially or noncommercially, provided that this License, the
+copyright notices, and the license notice saying this License applies
+to the Document are reproduced in all copies, and that you add no other
+conditions whatsoever to those of this License. You may not use
+technical measures to obstruct or control the reading or further
+copying of the copies you make or distribute. However, you may accept
+compensation in exchange for copies. If you distribute a large enough
+number of copies you must also follow the conditions in section 3.
+
+You may also lend copies, under the same conditions stated above, and
+you may publicly display copies.
+
+@item
+COPYING IN QUANTITY
+
+If you publish printed copies (or copies in media that commonly have
+printed covers) of the Document, numbering more than 100, and the
+Document's license notice requires Cover Texts, you must enclose the
+copies in covers that carry, clearly and legibly, all these Cover
+Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on
+the back cover. Both covers must also clearly and legibly identify
+you as the publisher of these copies. The front cover must present
+the full title with all words of the title equally prominent and
+visible. You may add other material on the covers in addition.
+Copying with changes limited to the covers, as long as they preserve
+the title of the Document and satisfy these conditions, can be treated
+as verbatim copying in other respects.
+
+If the required texts for either cover are too voluminous to fit
+legibly, you should put the first ones listed (as many as fit
+reasonably) on the actual cover, and continue the rest onto adjacent
+pages.
+
+If you publish or distribute Opaque copies of the Document numbering
+more than 100, you must either include a machine-readable Transparent
+copy along with each Opaque copy, or state in or with each Opaque copy
+a computer-network location from which the general network-using
+public has access to download using public-standard network protocols
+a complete Transparent copy of the Document, free of added material.
+If you use the latter option, you must take reasonably prudent steps,
+when you begin distribution of Opaque copies in quantity, to ensure
+that this Transparent copy will remain thus accessible at the stated
+location until at least one year after the last time you distribute an
+Opaque copy (directly or through your agents or retailers) of that
+edition to the public.
+
+It is requested, but not required, that you contact the authors of the
+Document well before redistributing any large number of copies, to give
+them a chance to provide you with an updated version of the Document.
+
+@item
+MODIFICATIONS
+
+You may copy and distribute a Modified Version of the Document under
+the conditions of sections 2 and 3 above, provided that you release
+the Modified Version under precisely this License, with the Modified
+Version filling the role of the Document, thus licensing distribution
+and modification of the Modified Version to whoever possesses a copy
+of it. In addition, you must do these things in the Modified Version:
+
+@enumerate A
+@item
+Use in the Title Page (and on the covers, if any) a title distinct
+from that of the Document, and from those of previous versions
+(which should, if there were any, be listed in the History section
+of the Document). You may use the same title as a previous version
+if the original publisher of that version gives permission.
+
+@item
+List on the Title Page, as authors, one or more persons or entities
+responsible for authorship of the modifications in the Modified
+Version, together with at least five of the principal authors of the
+Document (all of its principal authors, if it has fewer than five),
+unless they release you from this requirement.
+
+@item
+State on the Title page the name of the publisher of the
+Modified Version, as the publisher.
+
+@item
+Preserve all the copyright notices of the Document.
+
+@item
+Add an appropriate copyright notice for your modifications
+adjacent to the other copyright notices.
+
+@item
+Include, immediately after the copyright notices, a license notice
+giving the public permission to use the Modified Version under the
+terms of this License, in the form shown in the Addendum below.
+
+@item
+Preserve in that license notice the full lists of Invariant Sections
+and required Cover Texts given in the Document's license notice.
+
+@item
+Include an unaltered copy of this License.
+
+@item
+Preserve the section Entitled ``History'', Preserve its Title, and add
+to it an item stating at least the title, year, new authors, and
+publisher of the Modified Version as given on the Title Page. If
+there is no section Entitled ``History'' in the Document, create one
+stating the title, year, authors, and publisher of the Document as
+given on its Title Page, then add an item describing the Modified
+Version as stated in the previous sentence.
+
+@item
+Preserve the network location, if any, given in the Document for
+public access to a Transparent copy of the Document, and likewise
+the network locations given in the Document for previous versions
+it was based on. These may be placed in the ``History'' section.
+You may omit a network location for a work that was published at
+least four years before the Document itself, or if the original
+publisher of the version it refers to gives permission.
+
+@item
+For any section Entitled ``Acknowledgements'' or ``Dedications'', Preserve
+the Title of the section, and preserve in the section all the
+substance and tone of each of the contributor acknowledgements and/or
+dedications given therein.
+
+@item
+Preserve all the Invariant Sections of the Document,
+unaltered in their text and in their titles. Section numbers
+or the equivalent are not considered part of the section titles.
+
+@item
+Delete any section Entitled ``Endorsements''. Such a section
+may not be included in the Modified Version.
+
+@item
+Do not retitle any existing section to be Entitled ``Endorsements'' or
+to conflict in title with any Invariant Section.
+
+@item
+Preserve any Warranty Disclaimers.
+@end enumerate
+
+If the Modified Version includes new front-matter sections or
+appendices that qualify as Secondary Sections and contain no material
+copied from the Document, you may at your option designate some or all
+of these sections as invariant. To do this, add their titles to the
+list of Invariant Sections in the Modified Version's license notice.
+These titles must be distinct from any other section titles.
+
+You may add a section Entitled ``Endorsements'', provided it contains
+nothing but endorsements of your Modified Version by various
+parties---for example, statements of peer review or that the text has
+been approved by an organization as the authoritative definition of a
+standard.
+
+You may add a passage of up to five words as a Front-Cover Text, and a
+passage of up to 25 words as a Back-Cover Text, to the end of the list
+of Cover Texts in the Modified Version. Only one passage of
+Front-Cover Text and one of Back-Cover Text may be added by (or
+through arrangements made by) any one entity. If the Document already
+includes a cover text for the same cover, previously added by you or
+by arrangement made by the same entity you are acting on behalf of,
+you may not add another; but you may replace the old one, on explicit
+permission from the previous publisher that added the old one.
+
+The author(s) and publisher(s) of the Document do not by this License
+give permission to use their names for publicity for or to assert or
+imply endorsement of any Modified Version.
+
+@item
+COMBINING DOCUMENTS
+
+You may combine the Document with other documents released under this
+License, under the terms defined in section 4 above for modified
+versions, provided that you include in the combination all of the
+Invariant Sections of all of the original documents, unmodified, and
+list them all as Invariant Sections of your combined work in its
+license notice, and that you preserve all their Warranty Disclaimers.
+
+The combined work need only contain one copy of this License, and
+multiple identical Invariant Sections may be replaced with a single
+copy. If there are multiple Invariant Sections with the same name but
+different contents, make the title of each such section unique by
+adding at the end of it, in parentheses, the name of the original
+author or publisher of that section if known, or else a unique number.
+Make the same adjustment to the section titles in the list of
+Invariant Sections in the license notice of the combined work.
+
+In the combination, you must combine any sections Entitled ``History''
+in the various original documents, forming one section Entitled
+``History''; likewise combine any sections Entitled ``Acknowledgements'',
+and any sections Entitled ``Dedications''. You must delete all
+sections Entitled ``Endorsements.''
+
+@item
+COLLECTIONS OF DOCUMENTS
+
+You may make a collection consisting of the Document and other documents
+released under this License, and replace the individual copies of this
+License in the various documents with a single copy that is included in
+the collection, provided that you follow the rules of this License for
+verbatim copying of each of the documents in all other respects.
+
+You may extract a single document from such a collection, and distribute
+it individually under this License, provided you insert a copy of this
+License into the extracted document, and follow this License in all
+other respects regarding verbatim copying of that document.
+
+@item
+AGGREGATION WITH INDEPENDENT WORKS
+
+A compilation of the Document or its derivatives with other separate
+and independent documents or works, in or on a volume of a storage or
+distribution medium, is called an ``aggregate'' if the copyright
+resulting from the compilation is not used to limit the legal rights
+of the compilation's users beyond what the individual works permit.
+When the Document is included in an aggregate, this License does not
+apply to the other works in the aggregate which are not themselves
+derivative works of the Document.
+
+If the Cover Text requirement of section 3 is applicable to these
+copies of the Document, then if the Document is less than one half of
+the entire aggregate, the Document's Cover Texts may be placed on
+covers that bracket the Document within the aggregate, or the
+electronic equivalent of covers if the Document is in electronic form.
+Otherwise they must appear on printed covers that bracket the whole
+aggregate.
+
+@item
+TRANSLATION
+
+Translation is considered a kind of modification, so you may
+distribute translations of the Document under the terms of section 4.
+Replacing Invariant Sections with translations requires special
+permission from their copyright holders, but you may include
+translations of some or all Invariant Sections in addition to the
+original versions of these Invariant Sections. You may include a
+translation of this License, and all the license notices in the
+Document, and any Warranty Disclaimers, provided that you also include
+the original English version of this License and the original versions
+of those notices and disclaimers. In case of a disagreement between
+the translation and the original version of this License or a notice
+or disclaimer, the original version will prevail.
+
+If a section in the Document is Entitled ``Acknowledgements'',
+``Dedications'', or ``History'', the requirement (section 4) to Preserve
+its Title (section 1) will typically require changing the actual
+title.
+
+@item
+TERMINATION
+
+You may not copy, modify, sublicense, or distribute the Document
+except as expressly provided under this License. Any attempt
+otherwise to copy, modify, sublicense, or distribute it is void, and
+will automatically terminate your rights under this License.
+
+However, if you cease all violation of this License, then your license
+from a particular copyright holder is reinstated (a) provisionally,
+unless and until the copyright holder explicitly and finally
+terminates your license, and (b) permanently, if the copyright holder
+fails to notify you of the violation by some reasonable means prior to
+60 days after the cessation.
+
+Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License. If your rights have been terminated and not permanently
+reinstated, receipt of a copy of some or all of the same material does
+not give you any rights to use it.
+
+@item
+FUTURE REVISIONS OF THIS LICENSE
+
+The Free Software Foundation may publish new, revised versions
+of the GNU Free Documentation License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns. See
+@uref{http://www.gnu.org/copyleft/}.
+
+Each version of the License is given a distinguishing version number.
+If the Document specifies that a particular numbered version of this
+License ``or any later version'' applies to it, you have the option of
+following the terms and conditions either of that specified version or
+of any later version that has been published (not as a draft) by the
+Free Software Foundation. If the Document does not specify a version
+number of this License, you may choose any version ever published (not
+as a draft) by the Free Software Foundation. If the Document
+specifies that a proxy can decide which future versions of this
+License can be used, that proxy's public statement of acceptance of a
+version permanently authorizes you to choose that version for the
+Document.
+
+@item
+RELICENSING
+
+``Massive Multiauthor Collaboration Site'' (or ``MMC Site'') means any
+World Wide Web server that publishes copyrightable works and also
+provides prominent facilities for anybody to edit those works. A
+public wiki that anybody can edit is an example of such a server. A
+``Massive Multiauthor Collaboration'' (or ``MMC'') contained in the
+site means any set of copyrightable works thus published on the MMC
+site.
+
+``CC-BY-SA'' means the Creative Commons Attribution-Share Alike 3.0
+license published by Creative Commons Corporation, a not-for-profit
+corporation with a principal place of business in San Francisco,
+California, as well as future copyleft versions of that license
+published by that same organization.
+
+``Incorporate'' means to publish or republish a Document, in whole or
+in part, as part of another Document.
+
+An MMC is ``eligible for relicensing'' if it is licensed under this
+License, and if all works that were first published under this License
+somewhere other than this MMC, and subsequently incorporated in whole
+or in part into the MMC, (1) had no cover texts or invariant sections,
+and (2) were thus incorporated prior to November 1, 2008.
+
+The operator of an MMC Site may republish an MMC contained in the site
+under CC-BY-SA on the same site at any time before August 1, 2009,
+provided the MMC is eligible for relicensing.
+
+@end enumerate
+
+@page
+@heading ADDENDUM: How to use this License for your documents
+
+To use this License in a document you have written, include a copy of
+the License in the document and put the following copyright and
+license notices just after the title page:
+
+@smallexample
+@group
+ Copyright (C) @var{year} @var{your name}.
+ Permission is granted to copy, distribute and/or modify this document
+ under the terms of the GNU Free Documentation License, Version 1.3
+ or any later version published by the Free Software Foundation;
+ with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
+ Texts. A copy of the license is included in the section entitled ``GNU
+ Free Documentation License''.
+@end group
+@end smallexample
+
+If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts,
+replace the ``with@dots{}Texts.'' line with this:
+
+@smallexample
+@group
+ with the Invariant Sections being @var{list their titles}, with
+ the Front-Cover Texts being @var{list}, and with the Back-Cover Texts
+ being @var{list}.
+@end group
+@end smallexample
+
+If you have Invariant Sections without Cover Texts, or some other
+combination of the three, merge those two alternatives to suit the
+situation.
+
+If your document contains nontrivial examples of program code, we
+recommend releasing these examples in parallel under your choice of
+free software license, such as the GNU General Public License,
+to permit their use in free software.
+
+
+@c Local Variables:
+@c ispell-local-pdict: "ispell-dict"
+@c End:
diff --git a/emacs_gpr_mode.gpr b/emacs_gpr_mode.gpr
new file mode 100644
index 0000000000..ed3b61774b
--- /dev/null
+++ b/emacs_gpr_mode.gpr
@@ -0,0 +1,33 @@
+with "config/emacs_gpr_mode_config.gpr";
+with "standard_common_alire";
+with "wisi_alire";
+project Emacs_Gpr_Mode is
+
+ for Source_Dirs use (".", "config/");
+ for Languages use ("Ada", "C");
+
+ for Object_Dir use "obj/" & Emacs_Gpr_Mode_Config.Build_Profile;
+ for Create_Missing_Dirs use "True";
+ for Exec_Dir use "bin";
+ for Main use ("gpr_mode_wisi_parse.ads");
+
+ package Compiler is
+ case Emacs_Gpr_Mode_Config.Build_Profile is
+ when "release" =>
+ for Default_Switches ("Ada") use
Standard_Common_Alire.Release_Switches & Standard_Common_Alire.Style_Checks;
+
+ when "validation" | "development" =>
+ for Default_Switches ("Ada") use Standard_Common_Alire.Debug_Switches
& Standard_Common_Alire.Style_Checks;
+
+ end case;
+ end Compiler;
+
+ package Binder is
+ for Switches ("Ada") use ("-Es"); -- Symbolic traceback
+ end Binder;
+
+ package Install is
+ for Artifacts (".") use ("share");
+ end Install;
+
+end Emacs_Gpr_Mode;
diff --git a/gpr-indent-user-options.el b/gpr-indent-user-options.el
new file mode 100644
index 0000000000..174a5ebc0b
--- /dev/null
+++ b/gpr-indent-user-options.el
@@ -0,0 +1,48 @@
+;; user options shared by gpr mode indentation engines -*- lexical-binding:t
-*-
+;;
+;; Copyright (C) 2017, 2019 Free Software Foundation, Inc.
+;;
+;; Author: Stephen Leake <stephen_leake@member.fsf.org>
+;;
+;; 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
+
+(defgroup gpr-indentation nil
+ "Indentation options for gpr source."
+ :group 'gpr)
+
+(defcustom gpr-indent 3
+ "Size of default indentation, when no other indentation is used."
+ :type 'integer
+ :safe #'integerp)
+(make-variable-buffer-local 'gpr-indent)
+
+(defcustom gpr-indent-broken 2
+ "Indentation for the continuation of a broken line."
+ :type 'integer
+ :safe #'integerp)
+(make-variable-buffer-local 'gpr-indent-broken)
+
+(defcustom gpr-indent-when 3
+ "Indentation for `when' relative to `case'."
+ :type 'integer
+ :safe #'integerp)
+(make-variable-buffer-local 'gpr-indent-when)
+
+(provide 'gpr-indent-user-options)
+
+;; end file
diff --git a/gpr-mode.el b/gpr-mode.el
new file mode 100644
index 0000000000..d5b7db2ba7
--- /dev/null
+++ b/gpr-mode.el
@@ -0,0 +1,432 @@
+;; gpr-mode --- Major mode for editing GNAT project files -*-
lexical-binding:t -*-
+
+;; Copyright (C) 2004, 2007, 2008, 2012-2015, 2017 - 2020, 2022 Free Software
Foundation, Inc.
+
+;; Author: Stephen Leake <stephen_leake@member.fsf.org>
+;; Maintainer: Stephen Leake <stephen_leake@member.fsf.org>
+;; Version: 1.0.1
+;; package-requires: ((emacs "25.3") (wisi "4.1.1") (gnat-compiler "1.0"))
+;; URL: http://stephe-leake.org/ada/wisitoken.html
+
+;; This file is part of GNU Emacs.
+
+;; gpr-mode is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 3, or (at your option)
+;; any later version.
+
+;; gpr-mode is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+;;
+;;; Commentary:
+;;
+;;; History:
+;;
+;; The first gpr-mode was written by Rolf Ebert
+;; <rolf.ebert_nosp...@gmx.net> in 2004.
+;;
+;; Stephen Leake <stephen_leake@member.fsf.org> rewrote it in 2013 to
+;; use the wisi indentation engine.
+;;
+;;;;; Code:
+
+(require 'cl-lib)
+(require 'gnat-compiler)
+(require 'gpr-indent-user-options)
+(require 'gpr-process)
+(require 'gpr-skel)
+(require 'wisi-process-parse)
+(require 'wisi-prj)
+
+(defgroup gpr nil
+ "Major mode for editing gpr (Gnat Project File) source code in Emacs."
+ :group 'languages)
+
+(defvar gpr-mode-map
+ (let ((map (make-sparse-keymap)))
+ ;; C-c <letter> are reserved for users
+
+ ;; global-map has C-x ` 'next-error
+ (define-key map [return] 'wisi-indent-newline-indent)
+ ;; comment-dwim is in global map on M-;
+ (define-key map "\C-c\C-e" 'wisi-skel-expand)
+ (define-key map "\C-c\C-f" 'wisi-show-parse-error)
+ (define-key map "\C-c\C-i" 'wisi-indent-statement)
+ (define-key map "\C-c\C-o" 'ff-find-other-file)
+ (define-key map "\C-c\C-P" 'gpr-set-as-project)
+ (define-key map "\C-c\C-w" 'wisi-case-adjust-at-point)
+ (define-key map "\C-c\C-y" 'wisi-case-create-exception)
+ (define-key map "\C-c\C-\M-y" 'wisi-case-create-partial-exception)
+ (define-key map "\M-n" 'wisi-skel-next-placeholder)
+ (define-key map "\M-p" 'wisi-skel-prev-placeholder)
+
+ (wisi-case-activate-keys map)
+
+ map
+ ) "Local keymap used for GPR mode.")
+
+(defvar gpr-mode-menu (make-sparse-keymap "gpr"))
+(easy-menu-define gpr-mode-menu gpr-mode-map "Menu keymap for gpr mode"
+ '("gpr"
+ ("Help"
+ ["gpr Mode" (info "gpr-mode") t]
+ ["GNAT Reference Manual" (info "gnat_rm") t]
+ ["GNAT User Guide" (info "gnat_ugn") t]
+ ["Key bindings" describe-bindings t]
+ )
+
+ ["Customize" (customize-group 'gpr)]
+ ["------" nil nil]
+ ["Show current project" wisi-prj-show t]
+ ["Show project search path" wisi-prj-show-prj-path t]
+ ["Next compilation error" next-error t]
+ ["Show last parse error" wisi-show-parse-error t]
+ ["Other file" ff-find-other-file t]
+ ("Edit"
+ ["Indent Line or selection" indent-for-tab-command t]
+ ["Indent current statement" wisi-indent-statement t]
+ ["Indent Lines in File" (indent-region (point-min) (point-max))
t]
+ ["Expand skeleton" wisi-skel-expand t]
+ ["Next skeleton placeholder" wisi-skel-next-placeholder t]
+ ["Previous skeleton placeholder" wisi-skel-prev-placeholder t]
+ ["Comment/uncomment selection" comment-dwim t]
+ ["Fill Comment Paragraph" fill-paragraph t]
+ )
+ ))
+
+(defconst gpr-keywords
+ '(
+ "abstract"
+ "aggregate"
+ "at"
+ "case"
+ "configuration"
+ "end"
+ "extends"
+ "external"
+ "external_as_list"
+ "for"
+ "is"
+ "library"
+ "limited"
+ "null"
+ "others"
+ "package"
+ ;; "project" may also be a non-keyword attribute prefix; see
test/gpr/gds.gpr
+ "renames"
+ "standard"
+ "type"
+ "use"
+ "when"
+ "with"
+ )
+ "List of gpr mode keywords for font-lock and auto-casing.")
+
+(defvar gpr-font-lock-keywords
+ ;; Grammar actions set `font-lock-face' property for all
+ ;; non-keyword tokens that need it.
+ (list
+ (list (concat "\\<" (regexp-opt gpr-keywords t) "\\>") '(0
font-lock-keyword-face)))
+ "Expressions to highlight in gpr mode.")
+
+(defun gpr-ff-special-with ()
+ (let ((project-path (match-string 1)))
+ ;; project-path may be any of "foo", "foo.gpr", "../foo.gpr"
+ ;;
+ ;; The result of ff-special-constructs is used by
+ ;; ff-find-the-other-file with ff-search-directories and nil
+ ;; suffix list, so it must contain the relative path and the
+ ;; suffix
+ (if (file-name-extension project-path)
+ project-path
+ (concat project-path ".gpr"))
+ ))
+
+(defun gpr-set-ff-special-constructs ()
+ "Add gpr-specific pairs to `ff-special-constructs'."
+ (set (make-local-variable 'ff-special-constructs) nil)
+ (mapc (lambda (pair) (add-to-list 'ff-special-constructs pair))
+ ;; Each car is a regexp; if it matches at point, the cdr is
+ ;; invoked. Each cdr should return the absolute file name to
+ ;; go to.
+ (list
+ ;; A "with" clause; allow "foo_bar.gpr" and "../foo"
+ (cons "^with[ \t]+\"\\(\\(?:\\(?:\\sw\\|\\s.\\)\\|\\s_\\)+\\)\";"
+ 'gpr-ff-special-with)
+ )))
+
+(defun gpr-which-function ()
+ "Return the name of the package or project point is in or just after, or
nil."
+ (wisi-validate-cache (point-min) (point) nil 'navigate)
+ ;; No message on parse fail, since this could be called from
which-function-mode
+ (when (wisi-cache-covers-pos 'navigate (point))
+ (let ((cache (wisi-backward-cache))
+ done
+ project-pos
+ package-pos
+ decl-pos)
+ (while (and cache (not done))
+ ;; find attribute_declaration and package containing point (if any)
+ (cond
+ ((not (eq (wisi-cache-class cache) 'statement-start))
+ nil)
+
+ ((eq (wisi-cache-nonterm cache) 'attribute_declaration)
+ (setq decl-pos (point)))
+
+ ((eq (wisi-cache-nonterm cache) 'package_spec)
+ (setq package-pos (point))
+ (setq done t))
+
+ ((eq (wisi-cache-nonterm cache) 'simple_project_declaration)
+ (setq project-pos (point))
+ (setq done t))
+ )
+
+ (setq cache (wisi-goto-containing cache)))
+
+ (cond
+ (package-pos
+ (goto-char package-pos)
+ (setq done t))
+
+ (decl-pos
+ (goto-char decl-pos)
+ (setq done t))
+
+ (project-pos
+ (goto-char project-pos)
+ (setq done t))
+
+ (t ;; before project
+ (setq done nil))
+ )
+
+ (when done
+ (wisi-next-name))
+
+ )))
+
+(defun gpr-add-log-current-function ()
+ "For `add-log-current-defun-function'. Returns enclosing package or project
name."
+ ;; add-log-current-defun is typically called with point at the start
+ ;; of an ediff change section, which is before the start of the
+ ;; declaration of a new item. So go to the end of the current line
+ ;; first
+ (save-excursion
+ (end-of-line 1)
+ (gpr-which-function)))
+
+(defvar gpr-mode-syntax-table
+ (let ((table (make-syntax-table)))
+ ;; (info "(elisp)Syntax Class Table" "*info syntax class table*")
+ ;; make-syntax-table sets all alphanumeric to w, etc; so we only
+ ;; have to add gpr-specific things.
+
+ ;; string brackets. `%' is the obsolete alternative string
+ ;; bracket (arm J.2); if we make it syntax class ", it throws
+ ;; font-lock and indentation off the track, so we use syntax class
+ ;; $.
+ (modify-syntax-entry ?% "$" table)
+ (modify-syntax-entry ?\" "\"" table)
+
+ ;; punctuation; operators etc
+ (modify-syntax-entry ?- ". 124" table); operator, double hyphen as comment
+ (modify-syntax-entry ?& "." table)
+ (modify-syntax-entry ?. "." table)
+ (modify-syntax-entry ?: "." table)
+ (modify-syntax-entry ?= "." table)
+ (modify-syntax-entry ?> "." table)
+ (modify-syntax-entry ?\; "." table)
+ (modify-syntax-entry ?\\ "." table); default is escape; not correct for
gpr strings
+ (modify-syntax-entry ?\| "." table)
+
+ ;; and \f and \n end a comment
+ (modify-syntax-entry ?\f ">" table)
+ (modify-syntax-entry ?\n ">" table)
+
+ (modify-syntax-entry ?_ "_" table); symbol constituents, not word.
+
+ (modify-syntax-entry ?\( "()" table)
+ (modify-syntax-entry ?\) ")(" table)
+
+ ;; skeleton placeholder delimiters; see gpr-skel.el. We use generic
+ ;; comment delimiter class, not comment starter/comment ender, so
+ ;; these can be distinguished from line end.
+ (modify-syntax-entry ?{ "!" table)
+ (modify-syntax-entry ?} "!" table)
+
+ table
+ )
+ "Syntax table to be used for editing gpr source code.")
+
+;;;; wisi integration
+
+(defcustom gpr-auto-case t
+ "When non-nil, automatically change case of preceding word while
+typing. Casing of gpr keywords is done according to `gpr-case-keyword',
+identifiers according to `gpr-case-identifier'."
+ :group 'gpr
+ :type '(choice (const nil)
+ (const t))
+ :safe (lambda (val) (memq val '(nil t))))
+(make-variable-buffer-local 'gpr-auto-case)
+
+(defcustom gpr-case-keyword 'lower-case
+ "Indicate how to adjust case for language keywords.
+Value is one of lower-case, upper-case."
+ :group 'gpr
+ :type '(choice (const lower-case)
+ (const upper-case))
+ :safe #'symbolp)
+(make-variable-buffer-local 'gpr-case-keyword)
+
+(defcustom gpr-case-strict t
+ "If non-nil, force Mixed_Case for identifiers.
+Otherwise, allow UPPERCASE for identifiers."
+ :group 'gpr
+ :type 'boolean
+ :safe #'booleanp)
+(make-variable-buffer-local 'gpr-case-strict)
+
+(defcustom gpr-case-identifier 'mixed-case
+ "Indicates how to adjust the case of gpr keywords."
+ :group 'gpr
+ :type '(choice (const mixed-case)
+ (const lower-case)
+ (const upper-case))
+ ;; see comment on :safe at gpr-case-keyword
+ :safe (lambda (val) (memq val '(mixed-case lower-case upper-case))))
+(make-variable-buffer-local 'gpr-case-identifier)
+
+(defun gpr-case-adjust-p (_typed-char)
+ "For `wisi-case-adjust-p-function'."
+ ;; casing of 'project' in "Project'Project_Dir" vs "project GDS is"
+ (save-excursion
+ (let ((end (1+ (point)))
+ (start (progn (skip-syntax-backward "w")(point))))
+ (cond
+ ((string= "project" (downcase (buffer-substring-no-properties start
end)))
+ (cond
+ ((null (char-after end)) ;; at eob
+ nil)
+ ((= (char-after end) ?') ;; attribute Project'
+ t)
+ ((= (char-after end) ? ) ;; keyword project GDS
+ (wisi-case-keyword start end)
+ nil)
+ ))
+
+ (t t) ;; not "project"
+ ))))
+
+(cl-defstruct (gpr-wisi-parser (:include wisi-process--parser))
+ ;; no new slots
+ )
+
+(cl-defstruct (gpr-prj (:include wisi-prj))
+ ;; no new slots
+ )
+
+(defun gpr-prj-default (&optional name)
+ (make-gpr-prj :name (or name "_default_") :compiler (make-gnat-compiler)))
+
+(cl-defmethod wisi-prj-default ((prj gpr-prj))
+ (gpr-prj-default (wisi-prj-name prj)))
+
+(cl-defmethod wisi-parse-format-language-options ((_parser gpr-wisi-parser))
+ (format "%d %d %d"
+ gpr-indent
+ gpr-indent-broken
+ gpr-indent-when
+ ))
+
+(defconst gpr-wisi-language-protocol-version "1"
+ "Defines language-specific parser parameters.
+Must match wisi-gpr.ads Language_Protocol_Version.")
+
+(defcustom gpr-process-parse-exec "gpr_mode_wisi_parse"
+ "Name of executable to use for external process gpr parser,"
+ :type 'string
+ :group 'gpr)
+
+(defun gpr-set-as-project ()
+ "Set current buffer (a gpr file) as current project file."
+ (interactive)
+ (wisi-prj-dtrt-parse-file (buffer-file-name) (gpr-prj-default
(buffer-file-name)) (buffer-file-name)))
+
+;;;;
+;;;###autoload
+(defun gpr-mode ()
+ "The major mode for editing GNAT project files."
+
+ (interactive)
+ (kill-all-local-variables)
+ (setq major-mode 'gpr-mode)
+ (setq mode-name "GNAT Project")
+ (use-local-map gpr-mode-map)
+ (set-syntax-table gpr-mode-syntax-table)
+ (set 'case-fold-search t); gpr is case insensitive; the syntax parsing
requires this setting
+ (set (make-local-variable 'comment-start) "--")
+ (set (make-local-variable 'comment-end) "")
+ (set (make-local-variable 'comment-start-skip) "---*[ \t]*")
+ (set (make-local-variable 'comment-multi-line) nil)
+
+ (set (make-local-variable 'require-final-newline) t)
+
+ (set (make-local-variable 'font-lock-defaults)
+ '(gpr-font-lock-keywords
+ nil t
+ ((?\_ . "w"))))
+
+ (gpr-set-ff-special-constructs)
+ (setq ff-search-directories 'compilation-search-path);; includes project
search path
+
+ (set (make-local-variable 'add-log-current-defun-function)
+ 'gpr-add-log-current-function)
+
+ (wisi-setup
+ :indent-calculate nil
+ :post-indent-fail nil
+ :parser
+ (wisi-process-parse-get
+ (make-gpr-wisi-parser
+ :label "gpr"
+ :language-protocol-version gpr-wisi-language-protocol-version
+ :exec-file gpr-process-parse-exec
+ :face-table gpr-process-face-table
+ :token-table gpr-process-token-table
+ :repair-image gpr-process-repair-image
+ )))
+
+ (run-mode-hooks 'gpr-mode-hook)
+
+ (setq wisi-auto-case gpr-auto-case)
+ (setq wisi-case-identifier gpr-case-identifier)
+ (setq wisi-case-strict gpr-case-strict)
+ (setq wisi-language-keywords gpr-keywords)
+ (setq wisi-case-keyword gpr-case-keyword)
+ (setq wisi-case-adjust-p-function #'gpr-case-adjust-p)
+ )
+
+;;;###autoload
+(add-to-list 'auto-mode-alist '("\\.gpr\\'" . gpr-mode)) ; GNAT project files
+
+(put 'gpr-mode 'custom-mode-group 'gpr)
+
+(defvar gpr-parser 'process
+ "Indicate parser and lexer to use for gpr buffers:
+
+process : wisi elisp lexer, external process parser specified
+ by ‘gpr-process-parse-exec ’.
+")
+
+(provide 'gpr-mode)
+;;; gpr-mode.el ends here
diff --git a/gpr-mode.texi b/gpr-mode.texi
new file mode 100644
index 0000000000..da6b27f1c8
--- /dev/null
+++ b/gpr-mode.texi
@@ -0,0 +1,256 @@
+\input texinfo @c -*-texinfo-*-
+@settitle gpr Mode
+
+@copying
+Copyright @copyright{} 2013, 2019 Free Software Foundation, Inc.
+
+@quotation
+Permission is granted to copy, distribute and/or modify this document
+under the terms of the GNU Free Documentation License, Version 1.3 or
+any later version published by the Free Software Foundation; with no
+Invariant Sections, with the Front-Cover texts being ``A GNU Manual'',
+and with the Back-Cover Texts as in (a) below. A copy of the license
+is included in the section entitled ``GNU Free Documentation License''.
+
+(a) The FSF's Back-Cover Text is: ``You have the freedom to copy and
+modify this GNU manual. Buying copies from the FSF supports it in
+developing GNU and promoting software freedom.''
+@end quotation
+@end copying
+
+@dircategory Emacs
+@direntry
+* gpr mode: (gpr-mode). Emacs mode for editing and navigating gpr
files (gnat project files).
+@end direntry
+
+@titlepage
+@sp 10
+@title gpr Mode
+@sp 2
+@subtitle An Emacs major mode for editing and navigating gpr files
+@sp 2
+@page
+@vskip 0pt plus 1filll
+@insertcopying
+@end titlepage
+
+@contents
+
+@ifnottex
+@node Top, Overview, (dir), (dir)
+@end ifnottex
+
+@menu
+* Overview::
+* Installation::
+* Customization::
+* Moving Through Gpr Code::
+* Identifier completion::
+* Indentation::
+* Statement skeletons::
+* GNU Free Documentation License::
+* Index::
+@end menu
+
+@node Overview, Installation, Top, Top
+@chapter Overview
+gpr files are the project files used by the GNAT compiler and
+associated tools. They describe search paths, compiler options, etc.
+
+@xref{GNAT Project Manager,,GNAT Project Manager,gnat_ugn,GNAT Pro
+User's Guide}, for general information on gpr files.
+
+The Emacs mode for gpr files helps the user in reading
+existing code and facilitates writing new code.
+
+When you open a file with a file extension of @file{.gpr}, Emacs will
+automatically load and activate gpr mode.
+
+@node Installation, Customization, Overview, Top
+@chapter Installation
+
+gpr mode is distributed in the Gnu ELPA package archive, bundled with
+Ada mode; it can be installed via @code{M-x list-packages}
+(@pxref{Packages,,,emacs,Emacs User Guide}).
+
+gpr mode does not have a separate version; it uses the Ada mode
+version number. To see what version of Ada mode you have installed, do
+@kbd{M-x ada-mode-version}.
+
+@node Customization, Moving Through Gpr Code, Installation, Top
+@chapter Customization
+
+Indentation variables for gpr mode can be set via the menu @samp{gpr |
+Customize} from a gpr mode buffer. Click on the @samp{Help} button
+there for help on using customize. @xref{Indentation}.
+
+To modify a specific variable, you can directly call the function
+@code{customize-variable}; just type @kbd{M-x customize-variable
+@key{RET} @var{variable-name} @key{RET}}).
+
+Alternately, you can specify variable settings in the Emacs
+configuration file, @file{~/.emacs}. This file is coded in Emacs lisp,
+and the syntax to set a variable is the following:
+@example
+(setq variable-name value)
+@end example
+
+Some general Emacs settings that are useful for gpr files:
+@table @code
+@item delete-trailing-whitespace
+Deletes space, tab at end of line and blank lines at end of buffer.
+@item untabify
+Deletes tab characters that have crept into the file.
+@item indent-tabs-mode
+Don't insert tab characters when indenting.
+@item hippie-expand
+Bind @code{hippie-expand} to a key; it expands the word before point,
+using words from current buffer, other buffers, file names, etc; see
+@code{hippie-expand-try-functions-list}. You can also add
+@code{wisi-skel-hippie-try} to that list (@pxref{Statement skeletons}).
+@end table
+
+The above can all be set by the following code in your
+@file{~/.emacs}. Note that some are functions are added to
+@code{before-save-hook}; they run just before a buffer is written to disk.
+@example
+(setq-default indent-tabs-mode nil)
+(require 'gpr-mode)
+(add-to-list 'hippie-expand-try-functions-list 'wisi-skel-hippie-try)
+(define-key gpr-mode-map "\C-e" 'hippie-expand)
+(add-hook 'gpr-mode-hook
+ (lambda ()
+ (add-hook 'before-save-hook 'delete-trailing-whitespace nil t)
+ (add-hook 'before-save-hook
+ (lambda () (untabify (point-min) (point-max)))
+ nil t)))
+@end example
+
+@node Moving Through Gpr Code, Identifier completion, Customization, Top
+@chapter Moving Through Gpr Code
+
+These commands navigate through gpr code. All these functions are
+available through the gpr menu and keybindings.
+
+@table @kbd
+@item C-c C-o
+@findex ff-find-other-file
+If point is on a @code{with} clause, position point on the
+corresponding package declaration.
+
+@item C-u SPACE
+Jump back to the previous location.
+
+@item C-M-f
+Move to the end of the current declaration.
+
+@item C-M-b
+Move to the start of the current declaration.
+
+@end table
+
+@node Identifier completion, Indentation, Moving Through Gpr Code, Top
+@chapter Identifier completion
+
+Emacs provides a general way of completing identifiers: @kbd{M-/}
+(bound to @code{dabbrev-expand}). This is an easy way to type faster:
+you just have to type the first few letters of an identifier, and then
+loop through all the possible completions.
+
+If you have bound @code{hippie-expand}, that also uses
+@code{dabbrev-expand}.
+
+@kbd{M-/} works by parsing all open gpr files for possible
+completions.
+
+For instance, if the words @samp{my_identifier} and @samp{my_subprogram}
+are the only words starting with @samp{my} in any of the open gpr files,
+then you will have this scenario:
+
+@example
+You type: my@kbd{M-/}
+Emacs inserts: @samp{my_identifier}
+If you press @kbd{M-/} once again, Emacs replaces @samp{my_identifier} with
+@samp{my_subprogram}.
+Pressing @kbd{M-/} once more will bring you back to @samp{my_identifier}.
+@end example
+
+This is a very fast way to do completion, and the casing of words will
+also be respected.
+
+@node Indentation, Statement skeletons, Identifier completion, Top
+@chapter Indentation
+
+gpr mode comes with a full set of rules for automatic indentation. You
+can also configure the indentation, via the following variables:
+
+@table @asis
+@item @code{gpr-indent} (default value: 3)
+Number of columns for default indentation.
+
+@item @code{gpr-indent-broken} (default value: 2)
+Number of columns to indent the continuation of a broken line.
+
+@item @code{gpr-indent-when} (default value: 3)
+Indentation for @code{when} relative to @code{case}.
+
+@end table
+
+The following keys indent portions of the text:
+@table @kbd
+
+@item RET
+Insert and indent a new line.
+
+@item TAB
+Indent the current line, or the current region.
+
+@item C-c TAB
+Indent the current declaration.
+
+@end table
+
+The indentation algorithm relies on an error-correcting grammar parser
+to identify the syntactic role for keywords and other words in the
+code.
+
+@node Statement skeletons, GNU Free Documentation License, Indentation, Top
+@chapter Statement skeletons
+
+@kbd{C-c C-e} expands the previous one or two words into a statment
+skeleton. For example, @kbd{c a s e C-c C-e} expands to:
+
+@example
+case is
+when =>
+end case;
+@end example
+
+For named packages, the name is taken from
+the word before point, and the package keyword from the word
+before that:
+
+@example
+package A_Package
+@end example
+
+expands to:
+
+@example
+package A_Package is
+end A_Package;
+@end example
+
+Some expansions prompt for more information, such as
+a choice of license.
+
+@node GNU Free Documentation License, Index, Statement skeletons, Top
+@appendix GNU Free Documentation License
+@include doclicense.texi
+
+@node Index, , GNU Free Documentation License, Top
+@unnumbered Index
+
+@printindex fn
+
+@bye
diff --git a/gpr-process.el b/gpr-process.el
new file mode 100644
index 0000000000..59e611b917
--- /dev/null
+++ b/gpr-process.el
@@ -0,0 +1,148 @@
+;;; gpr-process.el --- Generated parser support file -*- buffer-read-only:t
lexical-binding:t -*-
+;; command line: wisitoken-bnf-generate.exe --generate LR1 Ada_Emacs re2c
PROCESS gpr.wy
+
+;; Copyright (C) 2013 - 2022 Free Software Foundation, Inc.
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 3, or (at
+;; your option) any later version.
+;;
+;; This software is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+;; General Public License for more details.
+;;
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
+
+(require 'wisi-process-parse)
+
+(defconst gpr-process-token-table
+ [WHITESPACE
+ NEW_LINE
+ COMMENT
+ GNAT_PREP
+ PLACEHOLDER
+ ABSTRACT
+ AT
+ AGGREGATE
+ CASE
+ CONFIGURATION
+ END
+ EXTENDS
+ EXTERNAL
+ EXTERNAL_AS_LIST
+ FOR
+ IS
+ LEFT_PAREN
+ LIBRARY
+ NULL
+ OTHERS
+ PACKAGE
+ PROJECT
+ RENAMES
+ RIGHT_PAREN
+ STANDARD
+ TYPE
+ USE
+ WHEN
+ WITH
+ AMPERSAND
+ COLON
+ COLON_EQUALS
+ COMMA
+ DOT
+ EQUAL_GREATER
+ QUOTE
+ SEMICOLON
+ VERTICAL_BAR
+ NUMERIC_LITERAL
+ IDENTIFIER
+ STRING_LITERAL
+ Wisi_EOI
+ wisitoken_accept
+ aggregate_g
+ attribute_declaration
+ attribute_prefix
+ attribute_reference
+ case_statement
+ case_item
+ case_items
+ compilation_unit
+ context_clause
+ context_clause_opt
+ declarative_item
+ declarative_items
+ declarative_items_opt
+ discrete_choice
+ discrete_choice_list
+ expression
+ external_value
+ identifier_opt
+ name
+ package_declaration
+ package_spec
+ package_extension
+ package_renaming
+ project_declaration_opt
+ project_extension
+ project_qualifier_opt
+ simple_declarative_item
+ simple_project_declaration
+ string_primary
+ string_list
+ term
+ typed_string_declaration
+ with_clause
+ Wisi_SOI
+ ])
+
+(defconst gpr-process-face-table
+ [
+ font-lock-function-name-face
+ font-lock-keyword-face
+ nil
+ ])
+
+(defconst gpr-process-repair-image
+ '(
+ (ABSTRACT . "abstract")
+ (AT . "at")
+ (AGGREGATE . "aggregate")
+ (CASE . "case")
+ (CONFIGURATION . "configuration")
+ (END . "end")
+ (EXTENDS . "extends")
+ (EXTERNAL . "external")
+ (EXTERNAL_AS_LIST . "external_as_list")
+ (FOR . "for")
+ (IS . "is")
+ (LEFT_PAREN . "(")
+ (LIBRARY . "library")
+ (NULL . "null")
+ (OTHERS . "others")
+ (PACKAGE . "package")
+ (PROJECT . "project")
+ (RENAMES . "renames")
+ (RIGHT_PAREN . ")")
+ (STANDARD . "standard")
+ (TYPE . "type")
+ (USE . "use")
+ (WHEN . "when")
+ (WITH . "with")
+ (AMPERSAND . "&")
+ (COLON . ":")
+ (COLON_EQUALS . ":=")
+ (COMMA . ",")
+ (DOT . ".")
+ (EQUAL_GREATER . "=>")
+ (QUOTE . "'")
+ (SEMICOLON . ";")
+ (VERTICAL_BAR . "|")
+ (NUMERIC_LITERAL . "1234567890")
+ (IDENTIFIER . "A_Bogus_Identifier")
+ (STRING_LITERAL . "\"\"")
+ ))
+
+(provide 'gpr-process)
diff --git a/gpr-skel.el b/gpr-skel.el
new file mode 100644
index 0000000000..9a53364fcf
--- /dev/null
+++ b/gpr-skel.el
@@ -0,0 +1,137 @@
+;; gpr-skel.el --- Extension to gpr-mode for inserting statement skeletons
-*- lexical-binding:t -*-
+
+;; Copyright (C) 2013-2015, 2018 - 2021 Free Software Foundation, Inc.
+
+;; Authors: Stephen Leake <stephen_leake@stephe-leake.org>
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
+
+;;; Design:
+;;
+;; The primary user command is `wisi-skel-expand', which inserts the
+;; skeleton associated with the previous word (possibly skipping a
+;; name).
+;;
+;; We don't define skeletons that prompt for most of the content; it
+;; is easier just to type in the buffer.
+;;
+;; These skeletons are not intended to teach a novice the language,
+;; just to make it easier to write code that the gpr-wisi parser
+;; likes, and handle repeated names nicely.
+
+;;; History:
+
+;; Created Dec 2013
+
+(require 'skeleton)
+(require 'wisi-skel)
+
+;;;;; user variables, example skeletons intended to be overwritten
+
+(defgroup gpr nil
+ "Major mode for editing GNAT project files in Emacs."
+ :group 'languages)
+
+(defcustom gpr-skel-initial-string "{header}\n{project}"
+ "String to insert in empty buffer.
+This could end in a token recognized by `gpr-skel-expand'."
+ :type 'string
+ :safe #'stringp)
+
+(define-skeleton gpr-skel-user-restricted
+ "Example copyright/license skeleton, with automatic year and owner."
+ ()
+ "-- Copyright (C) " (format-time-string "%Y ") user-full-name " All Rights
Reserved.\n"
+)
+
+(define-skeleton gpr-skel-gpl
+ "Example copyright/license skeleton, with automatic year and owner, GPLv3."
+ ()
+ "-- Copyright (C) " (format-time-string "%Y ") user-full-name " All Rights
Reserved.\n"
+ "--\n"
+ "-- This program is free software; you can redistribute it and/or\n"
+ "-- modify it under terms of the GNU General Public License as\n"
+ "-- published by the Free Software Foundation; either version 3, or (at\n"
+ "-- your option) any later version. This program is distributed in the\n"
+ "-- hope that it will be useful, but WITHOUT ANY WARRANTY; without even\n"
+ "-- the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\n"
+ "-- PURPOSE. See the GNU General Public License for more details. You\n"
+ "-- should have received a copy of the GNU General Public License\n"
+ "-- distributed with this program; see file COPYING. If not, write to\n"
+ "-- the Free Software Foundation, 51 Franklin Street, Suite 500, Boston,\n"
+ "-- MA 02110-1335, USA.\n"
+)
+
+;;;;; Gpr skeletons (alphabetical)
+
+(define-skeleton gpr-skel-case
+ "Insert case statement."
+ ()
+ "case " str " is\n"
+ "when " _ "=>\n"
+ "end case;")
+
+(define-skeleton gpr-skel-header
+ "Insert a file header comment, prompt for copyright owner/license.
+Each user will probably want to override this."
+ ()
+ "-- Abstract :\n"
+ "--\n"
+ "-- " _ "\n"
+ "--\n"
+ "{copyright_license}\n"
+ )
+
+(define-skeleton gpr-skel-package
+ "Insert a package with name from `str'."
+ "Package name: "
+ "package " str " is\n"
+ _
+ "end " str ";")
+
+(define-skeleton gpr-skel-project
+ "Insert a project with name from `str'."
+ "Project name: "
+ "project " str " is\n"
+ _
+ "end " str ";")
+
+;;;;; token alist, setup
+
+(defconst gpr-skel-token-alist
+ '(("case" . gpr-skel-case)
+ ("copyright_license"
+ ("GPL" . gpr-skel-gpl)
+ ("restricted" . gpr-skel-user-restricted))
+ ("header" . gpr-skel-header)
+ ("package" . gpr-skel-package)
+ ("project" . gpr-skel-project))
+"For `wisi-skel-token-alist', used by `wisi-skel-expand'.")
+
+(defun gpr-skel-setup ()
+ "Setup a buffer for gpr-skel."
+ (setq wisi-skel-token-alist gpr-skel-token-alist)
+ (add-hook 'skeleton-end-hook #'wisi-skel-enable-parse t)
+ (add-hook 'skeleton-end-hook #'wisi-indent-statement t)
+ (when (and gpr-skel-initial-string
+ (= (buffer-size) 0))
+ (insert gpr-skel-initial-string))
+ )
+
+(add-hook 'gpr-mode-hook #'gpr-skel-setup)
+
+(provide 'gpr-skel)
+;;; end of file
diff --git a/gpr.wy b/gpr.wy
new file mode 100644
index 0000000000..40733ff723
--- /dev/null
+++ b/gpr.wy
@@ -0,0 +1,379 @@
+;;; WisiToken grammar for GNAT project files
+;;
+;; Author: Stephen Leake <stephe-leake@stephe-leake.org>
+;; Maintainer: Stephen Leake <stephe-leake@stephe-leake.org>
+;; Created: Jan 2013
+;; Keywords: syntax
+
+%code copyright_license %{
+-- Copyright (C) 2013 - 2022 Free Software Foundation, Inc.
+
+-- This program is free software; you can redistribute it and/or
+-- modify it under the terms of the GNU General Public License as
+-- published by the Free Software Foundation; either version 3, or (at
+-- your option) any later version.
+--
+-- This software is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of
+-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+-- General Public License for more details.
+--
+-- You should have received a copy of the GNU General Public License
+-- along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
+}%
+
+;;; Commentary:
+;;
+;; This is a wisi grammar file for the gpr language. It is derived
+;; from the gprbuild user guide, with the following substitutions:
+;;
+;; simple_name -> IDENTIFIER
+;;
+;; and some simplifications. Repeating constructs are implemented with
+;; extra productions. Optional constructs are implemented by repeated
+;; productions
+
+;; GNAT GPL 2017 (info "(gprbuild_ug) Configuration File Reference")
+
+%token <punctuation> AMPERSAND "&"
+%token <punctuation> COLON ":"
+%token <punctuation> COLON_EQUALS ":="
+%token <punctuation> COMMA ","
+%token <punctuation> DOT "."
+%token <punctuation> EQUAL_GREATER "=>"
+%token <punctuation> QUOTE "'"
+%token <punctuation> SEMICOLON ";"
+%token <punctuation> VERTICAL_BAR "|"
+
+%case_insensitive
+
+%keyword ABSTRACT "abstract"
+%keyword AT "at"
+%keyword AGGREGATE "aggregate"
+%keyword CASE "case"
+%keyword CONFIGURATION "configuration"
+%keyword END "end"
+%keyword EXTENDS "extends"
+%keyword EXTERNAL "external"
+%keyword EXTERNAL_AS_LIST "external_as_list"
+%keyword FOR "for"
+%keyword IS "is"
+%keyword LEFT_PAREN "("
+%keyword LIBRARY "library"
+%keyword NULL "null"
+%keyword OTHERS "others"
+%keyword PACKAGE "package"
+%keyword PROJECT "project"
+%keyword RENAMES "renames"
+%keyword RIGHT_PAREN ")"
+%keyword STANDARD "standard"
+%keyword TYPE "type"
+%keyword USE "use"
+%keyword WHEN "when"
+%keyword WITH "with"
+
+%non_grammar <non-reporting> WHITESPACE %[ [ \t] ]%
+
+;; handle DOS or Unix newline
+%non_grammar <new-line> NEW_LINE %[ [\x0a]|[\x0d][\x0a] ]%
+
+%non_grammar <comment-new-line> COMMENT "--"
+
+;; gnatprep preprocessor lines
+%non_grammar <comment-new-line> GNAT_PREP %[ ("#if"|"#elsif"|"#else"|"#end") ]%
+
+;; skeleton placeholders.
+%non_grammar <comment-one-line> PLACEHOLDER "{" "}"
+
+%token <number> NUMERIC_LITERAL
+ %[ [0-9]+ ]%
+ "1234567890"
+
+%token <symbol> IDENTIFIER
+ %[ [a-zA-Z\x80-\U0010FFFF][0-9a-zA-Z_\x80-\U0010FFFF]* ]%
+ "A_Bogus_Identifier"
+
+%token <string-double-one-line> STRING_LITERAL
+ %[ (["][\x20-\x21\x23-\U0010FFFF]*["])+ ]%
+ '""'
+
+%start compilation_unit
+
+%generate LR1 Ada_Emacs re2c Process
+;; LR1 gives better error correction performance.
+
+%elisp_face font-lock-function-name-face
+%elisp_face font-lock-keyword-face
+%elisp_face nil
+
+%mckenzie_cost_default 4 4 2 2
+%mckenzie_enqueue_limit 10_000
+%mckenzie_check_limit 3
+%mckenzie_check_delta_limit 200
+
+%end_names_optional_option End_Names_Optional
+
+%conflict SHIFT term | REDUCE identifier_opt on token RIGHT_PAREN
+%conflict SHIFT case_item | REDUCE case_items on token WHEN
+
+;; grammar rules, non-terminal alphabetical order
+
+aggregate_g
+ : LEFT_PAREN string_list RIGHT_PAREN
+ %((wisi-indent-action [nil (wisi-anchored 1 1) (wisi-anchored 1 0)]))%
+ ;
+
+attribute_declaration
+ : FOR IDENTIFIER USE expression SEMICOLON
+ %((progn
+ (wisi-statement-action [1 statement-start 5 statement-end])
+ (wisi-name-action 2)
+ (wisi-face-apply-action [2 nil font-lock-function-name-face])
+ (wisi-indent-action [nil gpr-indent-broken nil gpr-indent-broken
nil])))%
+ | FOR IDENTIFIER LEFT_PAREN discrete_choice RIGHT_PAREN USE expression
SEMICOLON
+ %((progn
+ (wisi-statement-action [1 statement-start 8 statement-end])
+ (wisi-name-action 2)
+ (wisi-face-apply-action [2 nil font-lock-function-name-face])
+ (wisi-indent-action [nil gpr-indent-broken (- gpr-indent-broken 1)
gpr-indent-broken (- gpr-indent-broken 1) nil
+ gpr-indent-broken nil])))%
+ | FOR IDENTIFIER LEFT_PAREN discrete_choice RIGHT_PAREN USE expression AT
NUMERIC_LITERAL SEMICOLON
+ %((progn
+ (wisi-statement-action [1 statement-start 10 statement-end])
+ (wisi-name-action 2)
+ (wisi-face-apply-action [2 nil font-lock-function-name-face])
+ (wisi-indent-action [nil gpr-indent-broken (- gpr-indent-broken 1)
gpr-indent-broken (- gpr-indent-broken 1) nil
+ gpr-indent-broken nil nil nil])))%
+ | FOR EXTERNAL LEFT_PAREN STRING_LITERAL RIGHT_PAREN USE expression SEMICOLON
+ %((progn
+ (wisi-statement-action [1 statement-start 8 statement-end])
+ (wisi-indent-action [nil gpr-indent-broken (- gpr-indent-broken 1)
gpr-indent-broken (- gpr-indent-broken 1) nil
+ gpr-indent-broken nil])))%
+ ;
+
+;; (info "(gprbuild_ug)Attributes")
+attribute_prefix
+ : PROJECT
+ ;; not a keyword; no face
+ | name
+ ;
+
+attribute_reference
+ : attribute_prefix QUOTE IDENTIFIER
+ | attribute_prefix QUOTE IDENTIFIER LEFT_PAREN STRING_LITERAL RIGHT_PAREN
+ ;
+
+;; (info "(gprbuild_ug)Case Statements")
+case_statement
+ : CASE name IS case_items END CASE SEMICOLON
+ %((progn
+ (wisi-statement-action [1 statement-start 7 statement-end])
+ (wisi-indent-action [nil gpr-indent-broken nil [(wisi-block
gpr-indent-when) gpr-indent-when] nil nil nil])))%
+ ;
+
+;; declarations allowed in a case statement are a subset of
+;; declarative_items, but this simplifies the grammar.
+case_item
+ : WHEN discrete_choice_list EQUAL_GREATER declarative_items_opt
+ %((progn
+ (wisi-statement-action [1 motion])
+ (wisi-indent-action [nil gpr-indent-broken gpr-indent (wisi-block
gpr-indent)])))%
+ ;
+
+case_items
+ : ;; empty
+ | case_item
+ | case_items case_item
+ ;
+
+;; Compute indent for trailing comments.
+compilation_unit
+ : context_clause_opt project_qualifier_opt project_declaration_opt
+ %((wisi-indent-action [0 0 [0 0]]))%
+ ;
+
+context_clause
+ : with_clause
+ | context_clause with_clause
+ ;
+
+context_clause_opt
+ : ;; empty
+ | context_clause
+ ;
+
+;; (info "(gprbuild_ug)Declarations")
+declarative_item
+ : simple_declarative_item
+ | typed_string_declaration
+ | package_declaration
+ ;
+
+declarative_items
+ : declarative_item
+ | declarative_items declarative_item
+ ;
+
+declarative_items_opt
+ : ;; empty
+ | declarative_items
+ ;
+
+discrete_choice
+ : ;; empty
+ | STRING_LITERAL
+ | OTHERS
+ ;
+
+discrete_choice_list
+ : discrete_choice
+ | discrete_choice_list VERTICAL_BAR discrete_choice
+ ;
+
+;; (info "(gprbuild_ug)Expressions")
+expression
+ : term
+ | expression AMPERSAND term
+ ;
+
+external_value
+ : EXTERNAL aggregate_g
+ | EXTERNAL_AS_LIST aggregate_g
+ ;
+
+identifier_opt
+ : ;; empty
+ | IDENTIFIER
+ %()%
+ %((wisi-propagate-name 1))%
+ ;
+
+name
+ : identifier_opt
+ | name DOT IDENTIFIER
+ ;
+
+;; (info "(gprbuild_ug)Packages")
+package_declaration
+ : package_spec
+ | package_extension
+ | package_renaming
+ ;
+
+package_spec
+ : PACKAGE identifier_opt IS declarative_items_opt END identifier_opt
SEMICOLON
+ %((progn
+ (wisi-statement-action [1 statement-start 7 statement-end])
+ (wisi-name-action 2)
+ (wisi-face-apply-action [2 nil font-lock-function-name-face 6 nil
font-lock-function-name-face])
+ (wisi-indent-action [nil gpr-indent-broken nil [(wisi-block
gpr-indent) gpr-indent] nil nil nil])))%
+ %((wisi-match-names 2 6))%
+ ;
+
+package_extension
+ : PACKAGE identifier_opt EXTENDS name IS declarative_items_opt END
identifier_opt SEMICOLON
+ %((progn
+ (wisi-statement-action [1 statement-start 9 statement-end])
+ (wisi-name-action 2)
+ (wisi-face-apply-action [2 nil font-lock-function-name-face 8 nil
font-lock-function-name-face])
+ (wisi-indent-action [nil gpr-indent-broken nil gpr-indent-broken nil
[(wisi-block gpr-indent) gpr-indent] nil nil nil])))%
+ %((wisi-match-names 2 8))%
+ ;
+
+package_renaming
+ : PACKAGE identifier_opt RENAMES name SEMICOLON
+ %((progn
+ (wisi-statement-action [1 statement-start 5 statement-end])
+ (wisi-face-apply-action [2 nil font-lock-function-name-face 4 nil
font-lock-function-name-face])))%
+ ;
+
+project_declaration_opt
+ : ;; empty
+ | simple_project_declaration
+ | project_extension
+ ;
+
+project_extension
+ : PROJECT identifier_opt EXTENDS STRING_LITERAL IS declarative_items_opt END
identifier_opt SEMICOLON
+ %((progn
+ (wisi-statement-action [1 statement-start 9 statement-end])
+ (wisi-name-action 2)
+ (wisi-face-apply-action [1 nil font-lock-keyword-face 2 nil
font-lock-function-name-face 8 nil font-lock-function-name-face])
+ (wisi-indent-action [nil gpr-indent-broken nil gpr-indent-broken nil
[(wisi-block gpr-indent) gpr-indent] nil nil nil])))%
+ %((wisi-match-names 2 8))%
+ ;
+
+;; (info "(gprbuild_ug)Qualified Projects")
+project_qualifier_opt
+ : ;; empty
+ | ABSTRACT
+ | STANDARD
+ | AGGREGATE
+ | AGGREGATE LIBRARY
+ | LIBRARY
+ | CONFIGURATION
+ ;
+
+;; (info "(gprbuild_ug)Declarations" "*info gpr*")
+simple_declarative_item
+ : IDENTIFIER COLON_EQUALS expression SEMICOLON ;; variable_declaration
+ %((progn
+ (wisi-statement-action [1 statement-start 4 statement-end])
+ (wisi-indent-action [nil gpr-indent-broken gpr-indent-broken nil])))%
+ | IDENTIFIER COLON IDENTIFIER COLON_EQUALS expression SEMICOLON ;;
typed_variable_declaration
+ %((progn
+ (wisi-statement-action [1 statement-start 6 statement-end])
+ (wisi-indent-action [nil gpr-indent-broken gpr-indent-broken
gpr-indent-broken gpr-indent-broken nil])))%
+ | attribute_declaration
+ | case_statement
+ | NULL SEMICOLON
+ %((wisi-statement-action [1 statement-start 2 statement-end]))%
+ ;
+
+simple_project_declaration
+ : PROJECT identifier_opt IS declarative_items_opt END identifier_opt
SEMICOLON
+ %((progn
+ (wisi-statement-action [1 statement-start 7 statement-end])
+ (wisi-name-action 2)
+ (wisi-face-apply-action [1 nil font-lock-keyword-face
+ 2 nil font-lock-function-name-face
+ 6 nil font-lock-function-name-face])
+ (wisi-indent-action [nil gpr-indent-broken nil [(wisi-block
gpr-indent) gpr-indent] nil nil nil])))%
+ %((wisi-match-names 2 6))%
+ ;
+
+;; (info "(gprbuild_ug)Expressions")
+string_primary
+ : STRING_LITERAL
+ | name;; variable_name
+ | external_value
+ | attribute_reference
+ ;
+
+;; (info "(gprbuild_ug)Expressions")
+;; we merge that string_list into term, and use 'string_list' for
'string_expression {, string_expression}'
+string_list
+ : expression
+ | string_list COMMA expression
+ ;
+
+;; see string_list for info reference
+;; string_variable_name covered by string_primary
+term
+ : string_primary
+ | LEFT_PAREN RIGHT_PAREN
+ | aggregate_g
+ ;
+
+typed_string_declaration
+ : TYPE IDENTIFIER IS aggregate_g SEMICOLON
+ %((progn
+ (wisi-statement-action [1 statement-start 5 statement-end])
+ (wisi-indent-action [nil gpr-indent-broken gpr-indent-broken
gpr-indent-broken nil])))%
+ ;
+
+with_clause
+ : WITH string_list SEMICOLON
+ ;
+
+;;; end of file
diff --git a/gpr_mode_wisi_parse.ads b/gpr_mode_wisi_parse.ads
new file mode 100644
index 0000000000..87ecb615c4
--- /dev/null
+++ b/gpr_mode_wisi_parse.ads
@@ -0,0 +1,31 @@
+-- Abstract :
+--
+-- External process parser for gpr mode
+--
+-- Copyright (C) 2017 - 2020, 2022 Free Software Foundation, Inc.
+--
+-- This program is free software; you can redistribute it and/or
+-- modify it under terms of the GNU General Public License as
+-- published by the Free Software Foundation; either version 3, or (at
+-- your option) any later version. This program is distributed in the
+-- hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+-- the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+-- PURPOSE. See the GNU General Public License for more details. You
+-- should have received a copy of the GNU General Public License
+-- distributed with this program; see file COPYING. If not, write to
+-- the Free Software Foundation, 51 Franklin Street, Suite 500, Boston,
+-- MA 02110-1335, USA.
+
+pragma License (GPL);
+
+with Gen_Emacs_Wisi_LR_Parse;
+with Gpr_Process_Main;
+with Wisi.Gpr;
+procedure Gpr_Mode_Wisi_Parse is new Gen_Emacs_Wisi_LR_Parse
+ (Parse_Data_Type => Wisi.Gpr.Parse_Data_Type,
+ Name => "gpr_mode_wisi_parse",
+ Language_Protocol_Version => Wisi.Gpr.Language_Protocol_Version,
+ Language_Fixes => null,
+ Language_Matching_Begin_Tokens => null,
+ Language_String_ID_Set => null,
+ Create_Parser => Gpr_Process_Main.Create_Parser);
diff --git a/gpr_mode_wisi_parse.gpr b/gpr_mode_wisi_parse.gpr
new file mode 100644
index 0000000000..eed7869d78
--- /dev/null
+++ b/gpr_mode_wisi_parse.gpr
@@ -0,0 +1,91 @@
+-- Abstract :
+--
+-- build executables
+--
+-- Copyright (C) 2022 Free Software Foundation, Inc.
+--
+-- This program is free software; you can redistribute it and/or
+-- modify it under terms of the GNU General Public License as
+-- published by the Free Software Foundation; either version 3, or (at
+-- your option) any later version. This program is distributed in the
+-- hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+-- the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+-- PURPOSE. See the GNU General Public License for more details. You
+-- should have received a copy of the GNU General Public License
+-- distributed with this program; see file COPYING. If not, write to
+-- the Free Software Foundation, 51 Franklin Street, Suite 500, Boston,
+-- MA 02110-1335, USA.
+
+with "standard_common";
+with "wisi";
+project gpr_Mode_Wisi_Parse is
+
+ for Main use
+ ("gpr_mode_wisi_parse.ads",
+ "run_gpr_parse.ads"
+ );
+
+ for Source_Dirs use (".");
+
+ for Object_Dir use "obj";
+ for Exec_Dir use ".";
+
+ 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 Switches ("gpr_process_main.adb") use
+ Standard_Common.Compiler.Common_Switches &
+ Standard_Common.Compiler.Base_Style_Checks &
+ Standard_Common.Compiler.Base_Release_Switches & ("-O1",
"-gnat2020");
+
+ 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 Switches ("gpr_process.adb") use
+ Standard_Common.Compiler.Common_Switches &
+ Standard_Common.Compiler.Base_Style_Checks &
+ Standard_Common.Compiler.Base_Release_Switches & ("-O1",
"-gnat2020");
+
+ for Switches ("gpr_query.adb") use
+ -- WORKAROUND: GNAT Community 2021 with gnatcoll 21.2 and -gnat2020
reports a missing "overrides"
+ -- AdaCore ticket U618-051
+ Standard_Common.Compiler.Common_Switches &
+ "-gnaty3abcefhiklnprtx" & "-gnatyM120" & -- not overriding
+ Standard_Common.Compiler.Release_Switches;
+
+ for Default_Switches ("C") use
Standard_Common.Compiler.Release_Switches_C;
+ end case;
+
+ end Compiler;
+
+ package Builder is
+ -- Specifying some configuration pragmas can reduce parse times
+ -- by 10% or so, on some systems. But doing so only here causes
+ -- recompiling of wisitoken. If we add Global_ or Local_
+ -- Configuration_Pragmas in wisitoken.gpr, we get compilation
+ -- errors there. So we leave it up to users to patch this if
+ -- they want it.
+ -- for Global_Configuration_Pragmas use "config.pragmas";
+
+ for Global_Compilation_Switches ("Ada") use
Standard_Common.Builder'Global_Compilation_Switches ("Ada");
+
+ end Builder;
+
+ package Binder is
+ for default_switches ("Ada") use ("-E"); -- symbolic traceback
+ end Binder;
+
+end gpr_Mode_Wisi_Parse;
diff --git a/gpr_process_actions.adb b/gpr_process_actions.adb
new file mode 100644
index 0000000000..fb13f94ed1
--- /dev/null
+++ b/gpr_process_actions.adb
@@ -0,0 +1,418 @@
+-- generated parser support file. -*- buffer-read-only:t -*-
+-- command line: wisitoken-bnf-generate.exe --generate LR1 Ada_Emacs re2c
PROCESS gpr.wy
+--
+
+-- Copyright (C) 2013 - 2022 Free Software Foundation, Inc.
+
+-- This program is free software; you can redistribute it and/or
+-- modify it under the terms of the GNU General Public License as
+-- published by the Free Software Foundation; either version 3, or (at
+-- your option) any later version.
+--
+-- This software is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of
+-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+-- General Public License for more details.
+--
+-- You should have received a copy of the GNU General Public License
+-- along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
+
+with Wisi; use Wisi;
+with Wisi.Gpr; use Wisi.Gpr;
+with WisiToken.In_Parse_Actions; use WisiToken.In_Parse_Actions;
+package body Gpr_Process_Actions is
+
+ use WisiToken.Syntax_Trees.In_Parse_Actions;
+
+ procedure aggregate_g_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_Access)
+ 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, ((False, (Simple, (Label
=> None))), (False, (Simple, (Anchored_0,
+ 1, 1))), (False, (Simple, (Anchored_0, 1, 0)))));
+ end case;
+ end aggregate_g_0;
+
+ procedure attribute_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_Access)
+ 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, ((1, Statement_Start),
(5, Statement_End)));
+ Name_Action (Parse_Data, Tree, Nonterm, 2);
+ when Face =>
+ Face_Apply_Action (Parse_Data, Tree, Nonterm, (1 => (2, 2, 0)));
+ when Indent =>
+ Indent_Action_0 (Parse_Data, Tree, Nonterm, ((False, (Simple, (Label
=> None))), (False, (Simple, (Int,
+ Gpr_Indent_Broken))), (False, (Simple, (Label => None))), (False,
(Simple, (Int, Gpr_Indent_Broken))), (False,
+ (Simple, (Label => None)))));
+ end case;
+ end attribute_declaration_0;
+
+ procedure attribute_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_Access)
+ 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, ((1, Statement_Start),
(8, Statement_End)));
+ Name_Action (Parse_Data, Tree, Nonterm, 2);
+ when Face =>
+ Face_Apply_Action (Parse_Data, Tree, Nonterm, (1 => (2, 2, 0)));
+ when Indent =>
+ Indent_Action_0 (Parse_Data, Tree, Nonterm, ((False, (Simple, (Label
=> None))), (False, (Simple, (Int,
+ Gpr_Indent_Broken))), (False, (Simple, (Int, Gpr_Indent_Broken -
1))), (False, (Simple, (Int,
+ Gpr_Indent_Broken))), (False, (Simple, (Int, Gpr_Indent_Broken -
1))), (False, (Simple, (Label => None))),
+ (False, (Simple, (Int, Gpr_Indent_Broken))), (False, (Simple, (Label
=> None)))));
+ end case;
+ end attribute_declaration_1;
+
+ procedure attribute_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_Access)
+ 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, ((1, Statement_Start),
(10, Statement_End)));
+ Name_Action (Parse_Data, Tree, Nonterm, 2);
+ when Face =>
+ Face_Apply_Action (Parse_Data, Tree, Nonterm, (1 => (2, 2, 0)));
+ when Indent =>
+ Indent_Action_0 (Parse_Data, Tree, Nonterm, ((False, (Simple, (Label
=> None))), (False, (Simple, (Int,
+ Gpr_Indent_Broken))), (False, (Simple, (Int, Gpr_Indent_Broken -
1))), (False, (Simple, (Int,
+ Gpr_Indent_Broken))), (False, (Simple, (Int, Gpr_Indent_Broken -
1))), (False, (Simple, (Label => None))),
+ (False, (Simple, (Int, Gpr_Indent_Broken))), (False, (Simple, (Label
=> None))), (False, (Simple, (Label =>
+ None))), (False, (Simple, (Label => None)))));
+ end case;
+ end attribute_declaration_2;
+
+ procedure attribute_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_Access)
+ 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, ((1, Statement_Start),
(8, Statement_End)));
+ when Face =>
+ null;
+ when Indent =>
+ Indent_Action_0 (Parse_Data, Tree, Nonterm, ((False, (Simple, (Label
=> None))), (False, (Simple, (Int,
+ Gpr_Indent_Broken))), (False, (Simple, (Int, Gpr_Indent_Broken -
1))), (False, (Simple, (Int,
+ Gpr_Indent_Broken))), (False, (Simple, (Int, Gpr_Indent_Broken -
1))), (False, (Simple, (Label => None))),
+ (False, (Simple, (Int, Gpr_Indent_Broken))), (False, (Simple, (Label
=> None)))));
+ end case;
+ end attribute_declaration_3;
+
+ procedure case_statement_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_Access)
+ 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, ((1, Statement_Start),
(7, Statement_End)));
+ when Face =>
+ null;
+ when Indent =>
+ Indent_Action_0 (Parse_Data, Tree, Nonterm, ((False, (Simple, (Label
=> None))), (False, (Simple, (Int,
+ Gpr_Indent_Broken))), (False, (Simple, (Label => None))), (True,
(Simple, (Block, Gpr_Indent_When)), (Simple,
+ (Int, Gpr_Indent_When))), (False, (Simple, (Label => None))), (False,
(Simple, (Label => None))), (False,
+ (Simple, (Label => None)))));
+ end case;
+ end case_statement_0;
+
+ procedure case_item_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_Access)
+ 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, (1 => (1, Motion)));
+ when Face =>
+ null;
+ when Indent =>
+ Indent_Action_0 (Parse_Data, Tree, Nonterm, ((False, (Simple, (Label
=> None))), (False, (Simple, (Int,
+ Gpr_Indent_Broken))), (False, (Simple, (Int, Gpr_Indent))), (False,
(Simple, (Block, Gpr_Indent)))));
+ end case;
+ end case_item_0;
+
+ procedure compilation_unit_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_Access)
+ 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, ((False, (Simple, (Int,
0))), (False, (Simple, (Int, 0))), (True,
+ (Simple, (Int, 0)), (Simple, (Int, 0)))));
+ end case;
+ end compilation_unit_0;
+
+ function identifier_opt_1_check
+ (Tree : in WisiToken.Syntax_Trees.Tree;
+ Nonterm : in out WisiToken.Syntax_Trees.Recover_Token;
+ Tokens : in WisiToken.Syntax_Trees.Recover_Token_Array;
+ Recover_Active : in Boolean)
+ return WisiToken.Syntax_Trees.In_Parse_Actions.Status
+ is
+ pragma Unreferenced (Recover_Active);
+ begin
+ return Propagate_Name (Tree, Nonterm, Tokens, 1);
+ end identifier_opt_1_check;
+
+ procedure package_spec_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_Access)
+ 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, ((1, Statement_Start),
(7, Statement_End)));
+ Name_Action (Parse_Data, Tree, Nonterm, 2);
+ when Face =>
+ Face_Apply_Action (Parse_Data, Tree, Nonterm, ((2, 2, 0), (6, 2, 0)));
+ when Indent =>
+ Indent_Action_0 (Parse_Data, Tree, Nonterm, ((False, (Simple, (Label
=> None))), (False, (Simple, (Int,
+ Gpr_Indent_Broken))), (False, (Simple, (Label => None))), (True,
(Simple, (Block, Gpr_Indent)), (Simple, (Int,
+ Gpr_Indent))), (False, (Simple, (Label => None))), (False, (Simple,
(Label => None))), (False, (Simple, (Label
+ => None)))));
+ end case;
+ end package_spec_0;
+
+ function package_spec_0_check
+ (Tree : in WisiToken.Syntax_Trees.Tree;
+ Nonterm : in out WisiToken.Syntax_Trees.Recover_Token;
+ Tokens : in WisiToken.Syntax_Trees.Recover_Token_Array;
+ Recover_Active : in Boolean)
+ return WisiToken.Syntax_Trees.In_Parse_Actions.Status
+ is
+ pragma Unreferenced (Nonterm, Recover_Active);
+ begin
+ return Match_Names (Tree, Tokens, 2, 6, End_Names_Optional);
+ end package_spec_0_check;
+
+ procedure package_extension_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_Access)
+ 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, ((1, Statement_Start),
(9, Statement_End)));
+ Name_Action (Parse_Data, Tree, Nonterm, 2);
+ when Face =>
+ Face_Apply_Action (Parse_Data, Tree, Nonterm, ((2, 2, 0), (8, 2, 0)));
+ when Indent =>
+ Indent_Action_0 (Parse_Data, Tree, Nonterm, ((False, (Simple, (Label
=> None))), (False, (Simple, (Int,
+ Gpr_Indent_Broken))), (False, (Simple, (Label => None))), (False,
(Simple, (Int, Gpr_Indent_Broken))), (False,
+ (Simple, (Label => None))), (True, (Simple, (Block, Gpr_Indent)),
(Simple, (Int, Gpr_Indent))), (False,
+ (Simple, (Label => None))), (False, (Simple, (Label => None))),
(False, (Simple, (Label => None)))));
+ end case;
+ end package_extension_0;
+
+ function package_extension_0_check
+ (Tree : in WisiToken.Syntax_Trees.Tree;
+ Nonterm : in out WisiToken.Syntax_Trees.Recover_Token;
+ Tokens : in WisiToken.Syntax_Trees.Recover_Token_Array;
+ Recover_Active : in Boolean)
+ return WisiToken.Syntax_Trees.In_Parse_Actions.Status
+ is
+ pragma Unreferenced (Nonterm, Recover_Active);
+ begin
+ return Match_Names (Tree, Tokens, 2, 8, End_Names_Optional);
+ end package_extension_0_check;
+
+ procedure package_renaming_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_Access)
+ 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, ((1, Statement_Start),
(5, Statement_End)));
+ when Face =>
+ Face_Apply_Action (Parse_Data, Tree, Nonterm, ((2, 2, 0), (4, 2, 0)));
+ when Indent =>
+ null;
+ end case;
+ end package_renaming_0;
+
+ procedure project_extension_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_Access)
+ 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, ((1, Statement_Start),
(9, Statement_End)));
+ Name_Action (Parse_Data, Tree, Nonterm, 2);
+ when Face =>
+ Face_Apply_Action (Parse_Data, Tree, Nonterm, ((1, 2, 1), (2, 2, 0),
(8, 2, 0)));
+ when Indent =>
+ Indent_Action_0 (Parse_Data, Tree, Nonterm, ((False, (Simple, (Label
=> None))), (False, (Simple, (Int,
+ Gpr_Indent_Broken))), (False, (Simple, (Label => None))), (False,
(Simple, (Int, Gpr_Indent_Broken))), (False,
+ (Simple, (Label => None))), (True, (Simple, (Block, Gpr_Indent)),
(Simple, (Int, Gpr_Indent))), (False,
+ (Simple, (Label => None))), (False, (Simple, (Label => None))),
(False, (Simple, (Label => None)))));
+ end case;
+ end project_extension_0;
+
+ function project_extension_0_check
+ (Tree : in WisiToken.Syntax_Trees.Tree;
+ Nonterm : in out WisiToken.Syntax_Trees.Recover_Token;
+ Tokens : in WisiToken.Syntax_Trees.Recover_Token_Array;
+ Recover_Active : in Boolean)
+ return WisiToken.Syntax_Trees.In_Parse_Actions.Status
+ is
+ pragma Unreferenced (Nonterm, Recover_Active);
+ begin
+ return Match_Names (Tree, Tokens, 2, 8, End_Names_Optional);
+ end project_extension_0_check;
+
+ procedure simple_declarative_item_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_Access)
+ 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, ((1, Statement_Start),
(4, Statement_End)));
+ when Face =>
+ null;
+ when Indent =>
+ Indent_Action_0 (Parse_Data, Tree, Nonterm, ((False, (Simple, (Label
=> None))), (False, (Simple, (Int,
+ Gpr_Indent_Broken))), (False, (Simple, (Int, Gpr_Indent_Broken))),
(False, (Simple, (Label => None)))));
+ end case;
+ end simple_declarative_item_0;
+
+ procedure simple_declarative_item_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_Access)
+ 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, ((1, Statement_Start),
(6, Statement_End)));
+ when Face =>
+ null;
+ when Indent =>
+ Indent_Action_0 (Parse_Data, Tree, Nonterm, ((False, (Simple, (Label
=> None))), (False, (Simple, (Int,
+ Gpr_Indent_Broken))), (False, (Simple, (Int, Gpr_Indent_Broken))),
(False, (Simple, (Int,
+ Gpr_Indent_Broken))), (False, (Simple, (Int, Gpr_Indent_Broken))),
(False, (Simple, (Label => None)))));
+ end case;
+ end simple_declarative_item_1;
+
+ procedure simple_declarative_item_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_Access)
+ 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, ((1, Statement_Start),
(2, Statement_End)));
+ when Face =>
+ null;
+ when Indent =>
+ null;
+ end case;
+ end simple_declarative_item_4;
+
+ procedure simple_project_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_Access)
+ 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, ((1, Statement_Start),
(7, Statement_End)));
+ Name_Action (Parse_Data, Tree, Nonterm, 2);
+ when Face =>
+ Face_Apply_Action (Parse_Data, Tree, Nonterm, ((1, 2, 1), (2, 2, 0),
(6, 2, 0)));
+ when Indent =>
+ Indent_Action_0 (Parse_Data, Tree, Nonterm, ((False, (Simple, (Label
=> None))), (False, (Simple, (Int,
+ Gpr_Indent_Broken))), (False, (Simple, (Label => None))), (True,
(Simple, (Block, Gpr_Indent)), (Simple, (Int,
+ Gpr_Indent))), (False, (Simple, (Label => None))), (False, (Simple,
(Label => None))), (False, (Simple, (Label
+ => None)))));
+ end case;
+ end simple_project_declaration_0;
+
+ function simple_project_declaration_0_check
+ (Tree : in WisiToken.Syntax_Trees.Tree;
+ Nonterm : in out WisiToken.Syntax_Trees.Recover_Token;
+ Tokens : in WisiToken.Syntax_Trees.Recover_Token_Array;
+ Recover_Active : in Boolean)
+ return WisiToken.Syntax_Trees.In_Parse_Actions.Status
+ is
+ pragma Unreferenced (Nonterm, Recover_Active);
+ begin
+ return Match_Names (Tree, Tokens, 2, 6, End_Names_Optional);
+ end simple_project_declaration_0_check;
+
+ procedure typed_string_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_Access)
+ 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, ((1, Statement_Start),
(5, Statement_End)));
+ when Face =>
+ null;
+ when Indent =>
+ Indent_Action_0 (Parse_Data, Tree, Nonterm, ((False, (Simple, (Label
=> None))), (False, (Simple, (Int,
+ Gpr_Indent_Broken))), (False, (Simple, (Int, Gpr_Indent_Broken))),
(False, (Simple, (Int,
+ Gpr_Indent_Broken))), (False, (Simple, (Label => None)))));
+ end case;
+ end typed_string_declaration_0;
+
+end Gpr_Process_Actions;
diff --git a/gpr_process_actions.ads b/gpr_process_actions.ads
new file mode 100644
index 0000000000..91a46e6d0b
--- /dev/null
+++ b/gpr_process_actions.ads
@@ -0,0 +1,304 @@
+-- generated parser support file. -*- buffer-read-only:t -*-
+-- command line: wisitoken-bnf-generate.exe --generate LR1 Ada_Emacs re2c
PROCESS gpr.wy
+--
+
+-- Copyright (C) 2013 - 2022 Free Software Foundation, Inc.
+
+-- This program is free software; you can redistribute it and/or
+-- modify it under the terms of the GNU General Public License as
+-- published by the Free Software Foundation; either version 3, or (at
+-- your option) any later version.
+--
+-- This software is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of
+-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+-- General Public License for more details.
+--
+-- You should have received a copy of the GNU General Public License
+-- along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
+
+with WisiToken.Syntax_Trees;
+package Gpr_Process_Actions is
+
+ Descriptor : aliased constant WisiToken.Descriptor :=
+ (First_Terminal => 5,
+ Last_Terminal => 41,
+ First_Nonterminal => 42,
+ Last_Nonterminal => 75,
+ SOI_ID => 76,
+ EOI_ID => 41,
+ Accept_ID => 42,
+ Case_Insensitive => True,
+ New_Line_ID => 1,
+ String_1_ID => 32767,
+ String_2_ID => 40,
+ Image =>
+ (new String'("WHITESPACE"),
+ new String'("NEW_LINE"),
+ new String'("COMMENT"),
+ new String'("GNAT_PREP"),
+ new String'("PLACEHOLDER"),
+ new String'("ABSTRACT"),
+ new String'("AT"),
+ new String'("AGGREGATE"),
+ new String'("CASE"),
+ new String'("CONFIGURATION"),
+ new String'("END"),
+ new String'("EXTENDS"),
+ new String'("EXTERNAL"),
+ new String'("EXTERNAL_AS_LIST"),
+ new String'("FOR"),
+ new String'("IS"),
+ new String'("LEFT_PAREN"),
+ new String'("LIBRARY"),
+ new String'("NULL"),
+ new String'("OTHERS"),
+ new String'("PACKAGE"),
+ new String'("PROJECT"),
+ new String'("RENAMES"),
+ new String'("RIGHT_PAREN"),
+ new String'("STANDARD"),
+ new String'("TYPE"),
+ new String'("USE"),
+ new String'("WHEN"),
+ new String'("WITH"),
+ new String'("AMPERSAND"),
+ new String'("COLON"),
+ new String'("COLON_EQUALS"),
+ new String'("COMMA"),
+ new String'("DOT"),
+ new String'("EQUAL_GREATER"),
+ new String'("QUOTE"),
+ new String'("SEMICOLON"),
+ new String'("VERTICAL_BAR"),
+ new String'("NUMERIC_LITERAL"),
+ new String'("IDENTIFIER"),
+ new String'("STRING_LITERAL"),
+ new String'("Wisi_EOI"),
+ new String'("wisitoken_accept"),
+ new String'("aggregate_g"),
+ new String'("attribute_declaration"),
+ new String'("attribute_prefix"),
+ new String'("attribute_reference"),
+ new String'("case_statement"),
+ new String'("case_item"),
+ new String'("case_items"),
+ new String'("compilation_unit"),
+ new String'("context_clause"),
+ new String'("context_clause_opt"),
+ new String'("declarative_item"),
+ new String'("declarative_items"),
+ new String'("declarative_items_opt"),
+ new String'("discrete_choice"),
+ new String'("discrete_choice_list"),
+ new String'("expression"),
+ new String'("external_value"),
+ new String'("identifier_opt"),
+ new String'("name"),
+ new String'("package_declaration"),
+ new String'("package_spec"),
+ new String'("package_extension"),
+ new String'("package_renaming"),
+ new String'("project_declaration_opt"),
+ new String'("project_extension"),
+ new String'("project_qualifier_opt"),
+ new String'("simple_declarative_item"),
+ new String'("simple_project_declaration"),
+ new String'("string_primary"),
+ new String'("string_list"),
+ new String'("term"),
+ new String'("typed_string_declaration"),
+ new String'("with_clause"),
+ new String'("Wisi_SOI")),
+ Terminal_Image_Width => 16,
+ Image_Width => 26,
+ Last_Lookahead => 41);
+
+ type Token_Enum_ID is
+ (WHITESPACE_ID,
+ NEW_LINE_ID,
+ COMMENT_ID,
+ GNAT_PREP_ID,
+ PLACEHOLDER_ID,
+ ABSTRACT_ID,
+ AT_ID,
+ AGGREGATE_ID,
+ CASE_ID,
+ CONFIGURATION_ID,
+ END_ID,
+ EXTENDS_ID,
+ EXTERNAL_ID,
+ EXTERNAL_AS_LIST_ID,
+ FOR_ID,
+ IS_ID,
+ LEFT_PAREN_ID,
+ LIBRARY_ID,
+ NULL_ID,
+ OTHERS_ID,
+ PACKAGE_ID,
+ PROJECT_ID,
+ RENAMES_ID,
+ RIGHT_PAREN_ID,
+ STANDARD_ID,
+ TYPE_ID,
+ USE_ID,
+ WHEN_ID,
+ WITH_ID,
+ AMPERSAND_ID,
+ COLON_ID,
+ COLON_EQUALS_ID,
+ COMMA_ID,
+ DOT_ID,
+ EQUAL_GREATER_ID,
+ QUOTE_ID,
+ SEMICOLON_ID,
+ VERTICAL_BAR_ID,
+ NUMERIC_LITERAL_ID,
+ IDENTIFIER_ID,
+ STRING_LITERAL_ID,
+ Wisi_EOI_ID,
+ wisitoken_accept_ID,
+ aggregate_g_ID,
+ attribute_declaration_ID,
+ attribute_prefix_ID,
+ attribute_reference_ID,
+ case_statement_ID,
+ case_item_ID,
+ case_items_ID,
+ compilation_unit_ID,
+ context_clause_ID,
+ context_clause_opt_ID,
+ declarative_item_ID,
+ declarative_items_ID,
+ declarative_items_opt_ID,
+ discrete_choice_ID,
+ discrete_choice_list_ID,
+ expression_ID,
+ external_value_ID,
+ identifier_opt_ID,
+ name_ID,
+ package_declaration_ID,
+ package_spec_ID,
+ package_extension_ID,
+ package_renaming_ID,
+ project_declaration_opt_ID,
+ project_extension_ID,
+ project_qualifier_opt_ID,
+ simple_declarative_item_ID,
+ simple_project_declaration_ID,
+ string_primary_ID,
+ string_list_ID,
+ term_ID,
+ typed_string_declaration_ID,
+ with_clause_ID,
+ Wisi_SOI_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 aggregate_g_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_Access);
+ procedure attribute_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_Access);
+ procedure attribute_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_Access);
+ procedure attribute_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_Access);
+ procedure attribute_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_Access);
+ procedure case_statement_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_Access);
+ procedure case_item_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_Access);
+ procedure compilation_unit_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_Access);
+ procedure package_spec_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_Access);
+ procedure package_extension_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_Access);
+ procedure package_renaming_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_Access);
+ procedure project_extension_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_Access);
+ procedure simple_declarative_item_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_Access);
+ procedure simple_declarative_item_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_Access);
+ procedure simple_declarative_item_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_Access);
+ procedure simple_project_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_Access);
+ procedure typed_string_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_Access);
+ function identifier_opt_1_check
+ (Tree : in WisiToken.Syntax_Trees.Tree;
+ Nonterm : in out WisiToken.Syntax_Trees.Recover_Token;
+ Tokens : in WisiToken.Syntax_Trees.Recover_Token_Array;
+ Recover_Active : in Boolean)
+ return WisiToken.Syntax_Trees.In_Parse_Actions.Status;
+ function package_spec_0_check
+ (Tree : in WisiToken.Syntax_Trees.Tree;
+ Nonterm : in out WisiToken.Syntax_Trees.Recover_Token;
+ Tokens : in WisiToken.Syntax_Trees.Recover_Token_Array;
+ Recover_Active : in Boolean)
+ return WisiToken.Syntax_Trees.In_Parse_Actions.Status;
+ function package_extension_0_check
+ (Tree : in WisiToken.Syntax_Trees.Tree;
+ Nonterm : in out WisiToken.Syntax_Trees.Recover_Token;
+ Tokens : in WisiToken.Syntax_Trees.Recover_Token_Array;
+ Recover_Active : in Boolean)
+ return WisiToken.Syntax_Trees.In_Parse_Actions.Status;
+ function project_extension_0_check
+ (Tree : in WisiToken.Syntax_Trees.Tree;
+ Nonterm : in out WisiToken.Syntax_Trees.Recover_Token;
+ Tokens : in WisiToken.Syntax_Trees.Recover_Token_Array;
+ Recover_Active : in Boolean)
+ return WisiToken.Syntax_Trees.In_Parse_Actions.Status;
+ function simple_project_declaration_0_check
+ (Tree : in WisiToken.Syntax_Trees.Tree;
+ Nonterm : in out WisiToken.Syntax_Trees.Recover_Token;
+ Tokens : in WisiToken.Syntax_Trees.Recover_Token_Array;
+ Recover_Active : in Boolean)
+ return WisiToken.Syntax_Trees.In_Parse_Actions.Status;
+ Partial_Parse_Active : aliased Boolean := False;
+ Partial_Parse_Byte_Goal : aliased WisiToken.Buffer_Pos :=
WisiToken.Buffer_Pos'Last;
+end Gpr_Process_Actions;
diff --git a/gpr_process_main.adb b/gpr_process_main.adb
new file mode 100644
index 0000000000..9618d53f91
--- /dev/null
+++ b/gpr_process_main.adb
@@ -0,0 +1,2640 @@
+-- generated parser support file. -*- buffer-read-only:t -*-
+-- command line: wisitoken-bnf-generate.exe --generate LR1 Ada_Emacs re2c
PROCESS gpr.wy
+--
+
+-- Copyright (C) 2013 - 2022 Free Software Foundation, Inc.
+
+-- This program is free software; you can redistribute it and/or
+-- modify it under the terms of the GNU General Public License as
+-- published by the Free Software Foundation; either version 3, or (at
+-- your option) any later version.
+--
+-- This software is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of
+-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+-- General Public License for more details.
+--
+-- You should have received a copy of the GNU General Public License
+-- along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
+
+with SAL;
+with WisiToken.Lexer.re2c;
+with gpr_re2c_c;
+with Gpr_Process_Actions; use Gpr_Process_Actions;
+package body Gpr_Process_Main is
+
+ function Is_Block_Delimited (ID : in WisiToken.Token_ID) return Boolean
+ is begin
+ case To_Token_Enum (ID) is
+ when
+ COMMENT_ID |
+ GNAT_PREP_ID |
+ PLACEHOLDER_ID |
+ STRING_LITERAL_ID => return True;
+ when others => return False;
+ end case;
+ end Is_Block_Delimited;
+
+ function Same_Block_Delimiters (ID : in WisiToken.Token_ID) return Boolean
+ is begin
+ case To_Token_Enum (ID) is
+ when COMMENT_ID => return False;
+ when GNAT_PREP_ID => return False;
+ when PLACEHOLDER_ID => return False;
+ when STRING_LITERAL_ID => return True;
+ when others => return False;
+ end case;
+ end Same_Block_Delimiters;
+
+ function Escape_Delimiter_Doubled (ID : in WisiToken.Token_ID) return
Boolean
+ is begin
+ case To_Token_Enum (ID) is
+ when others => return False;
+ end case;
+ end Escape_Delimiter_Doubled;
+
+ function Start_Delimiter_Length (ID : in WisiToken.Token_ID) return Integer
+ is begin
+ case To_Token_Enum (ID) is
+ when COMMENT_ID => return 2;
+ when GNAT_PREP_ID => return 33;
+ when PLACEHOLDER_ID => return 1;
+ when STRING_LITERAL_ID => return 1;
+ when others => raise SAL.Programmer_Error; return 0;
+ end case;
+ end Start_Delimiter_Length;
+
+ function End_Delimiter_Length (ID : in WisiToken.Token_ID) return Integer
+ is begin
+ case To_Token_Enum (ID) is
+ when
+ COMMENT_ID |
+ GNAT_PREP_ID |
+ STRING_LITERAL_ID => return 1;
+ when PLACEHOLDER_ID => return 1;
+ when others => raise SAL.Programmer_Error; return 0;
+ end case;
+ end End_Delimiter_Length;
+
+ function New_Line_Is_End_Delimiter (ID : in WisiToken.Token_ID) return
Boolean
+ is begin
+ return
+ (case To_Token_Enum (ID) is
+ when COMMENT_ID => True,
+ when GNAT_PREP_ID => True,
+ when PLACEHOLDER_ID => True,
+ when STRING_LITERAL_ID => True,
+ when others => raise SAL.Programmer_Error);
+ end New_Line_Is_End_Delimiter;
+
+ function Find_End_Delimiter
+ (Source : in WisiToken.Lexer.Source;
+ ID : in WisiToken.Token_ID;
+ Token_Start : in WisiToken.Buffer_Pos)
+ return WisiToken.Buffer_Pos
+ is begin
+ return
+ (case To_Token_Enum (ID) is
+ when COMMENT_ID => WisiToken.Lexer.Find_New_Line (Source,
Token_Start),
+ when GNAT_PREP_ID => WisiToken.Lexer.Find_New_Line (Source,
Token_Start),
+ when PLACEHOLDER_ID => WisiToken.Lexer.Find_String (Source,
Token_Start, "}"),
+ when STRING_LITERAL_ID => WisiToken.Lexer.Find_String_Or_New_Line
(Source, Token_Start, """"),
+ when others => raise SAL.Programmer_Error);
+ end Find_End_Delimiter;
+
+ function Find_Scan_End
+ (Source : in WisiToken.Lexer.Source;
+ ID : in WisiToken.Token_ID;
+ Region : in WisiToken.Buffer_Region;
+ Inserted : in Boolean;
+ Start : in Boolean)
+ return WisiToken.Buffer_Pos
+ is
+ use WisiToken;
+ begin
+ return
+ (case To_Token_Enum (ID) is
+ when COMMENT_ID =>
+ (if Inserted then Region.Last
+ elsif Start then Region.Last
+ else Lexer.Find_New_Line (Source, Region.Last)),
+ when GNAT_PREP_ID =>
+ (if Inserted then Region.Last
+ elsif Start then Region.Last
+ else Lexer.Find_New_Line (Source, Region.Last)),
+ when PLACEHOLDER_ID =>
+ (if Inserted then Region.Last
+ elsif Start then Region.Last
+ else Lexer.Find_String_Or_New_Line (Source, Region.Last, "{")),
+ when STRING_LITERAL_ID => Lexer.Find_New_Line (Source, Region.Last),
+ when others => raise SAL.Programmer_Error);
+ end Find_Scan_End;
+
+ function Contains_End_Delimiter
+ (Source : in WisiToken.Lexer.Source;
+ ID : in WisiToken.Token_ID;
+ Region : in WisiToken.Buffer_Region)
+ return WisiToken.Base_Buffer_Pos
+ is
+ use WisiToken;
+ begin
+ return
+ (case To_Token_Enum (ID) is
+ when COMMENT_ID => Lexer.Find_New_Line (Source, Region),
+ when GNAT_PREP_ID => Lexer.Find_New_Line (Source, Region),
+ when PLACEHOLDER_ID => Lexer.Find_String_Or_New_Line (Source, Region,
"}"),
+ when STRING_LITERAL_ID => Lexer.Find_String_Or_New_Line (Source,
Region, """"),
+ when others => raise SAL.Programmer_Error);
+ end Contains_End_Delimiter;
+
+ function Line_Begin_Char_Pos
+ (Source : in WisiToken.Lexer.Source;
+ Token : in WisiToken.Lexer.Token;
+ Line : in WisiToken.Line_Number_Type)
+ return WisiToken.Buffer_Pos
+ is
+ pragma Unreferenced (Source, Line);
+ use all type WisiToken.Base_Buffer_Pos;
+ begin
+ case To_Token_Enum (Token.ID) is
+ when NEW_LINE_ID => return Token.Char_Region.Last + 1;
+ when COMMENT_ID => return Token.Char_Region.Last + 1;
+ when GNAT_PREP_ID => return Token.Char_Region.Last + 1;
+ when others => raise SAL.Programmer_Error;
+ end case;
+ end Line_Begin_Char_Pos;
+
+ function Can_Contain_New_Line (ID : in WisiToken.Token_ID) return Boolean
+ is begin
+ case To_Token_Enum (ID) is
+ when NEW_LINE_ID => return True;
+ when COMMENT_ID => return True;
+ when GNAT_PREP_ID => return True;
+ when others => return False;
+ end case;
+ end Can_Contain_New_Line;
+
+ function Terminated_By_New_Line (ID : in WisiToken.Token_ID) return Boolean
+ is begin
+ case To_Token_Enum (ID) is
+ when NEW_LINE_ID => return True;
+ when COMMENT_ID => return True;
+ when GNAT_PREP_ID => return True;
+ when STRING_LITERAL_ID => return True;
+ when others => return False;
+ end case;
+ end Terminated_By_New_Line;
+
+ package Lexer is new WisiToken.Lexer.re2c
+ (gpr_re2c_c.New_Lexer,
+ gpr_re2c_c.Free_Lexer,
+ gpr_re2c_c.Reset_Lexer,
+ gpr_re2c_c.Set_Verbosity,
+ gpr_re2c_c.Set_Position,
+ gpr_re2c_c.Next_Token,
+ Is_Block_Delimited,
+ Same_Block_Delimiters,
+ Escape_Delimiter_Doubled,
+ Start_Delimiter_Length,
+ End_Delimiter_Length,
+ New_Line_Is_End_Delimiter,
+ Find_End_Delimiter,
+ Contains_End_Delimiter,
+ Find_Scan_End,
+ Line_Begin_Char_Pos,
+ Can_Contain_New_Line,
+ Terminated_By_New_Line);
+
+ function Create_Parse_Table
+ return WisiToken.Parse.LR.Parse_Table_Ptr
+ is
+ use WisiToken.Parse.LR;
+ McKenzie_Param : constant McKenzie_Param_Type :=
+ (First_Terminal => 5,
+ Last_Terminal => 41,
+ First_Nonterminal => 42,
+ Last_Nonterminal => 75,
+ Insert =>
+ (4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4),
+ Delete =>
+ (4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4),
+ Push_Back =>
+ (2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2),
+ Undo_Reduce =>
+ (2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2),
+ Minimal_Complete_Cost_Delta => -1,
+ Fast_Forward => 0,
+ Matching_Begin => 0,
+ Ignore_Check_Fail => 2,
+ Check_Limit => 3,
+ Zombie_Limit => 4,
+ Check_Delta_Limit => 200,
+ Enqueue_Limit => 10000);
+
+ Table : constant Parse_Table_Ptr := new Parse_Table
+ (State_First => 0,
+ State_Last => 322,
+ First_Terminal => 5,
+ Last_Terminal => 41,
+ First_Nonterminal => 42,
+ Last_Nonterminal => 75);
+ begin
+ declare
+ procedure Subr_1
+ is begin
+ Table.States (0).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (0), 5, Reduce, (52, 0), 0);
+ Add_Action (Table.States (0), 7, Reduce, (52, 0), 0);
+ Add_Action (Table.States (0), 9, Reduce, (52, 0), 0);
+ Add_Action (Table.States (0), 17, Reduce, (52, 0), 0);
+ Add_Action (Table.States (0), 21, Reduce, (52, 0), 0);
+ Add_Action (Table.States (0), 24, Reduce, (52, 0), 0);
+ Add_Action (Table.States (0), 28, (75, 0), 1);
+ Add_Action (Table.States (0), 41, Reduce, (52, 0), 0);
+ Table.States (0).Goto_List.Set_Capacity (4);
+ Add_Goto (Table.States (0), 50, 2);
+ Add_Goto (Table.States (0), 51, 3);
+ Add_Goto (Table.States (0), 52, 4);
+ Add_Goto (Table.States (0), 75, 5);
+ Table.States (1).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (1), 12, (59, 0), 6);
+ Add_Action (Table.States (1), 13, (59, 1), 7);
+ Add_Action (Table.States (1), 16, (43, 0), 8);
+ Add_Action (Table.States (1), 21, (45, 0), 9);
+ Add_Action (Table.States (1), 29, Reduce, (60, 0), 0);
+ Add_Action (Table.States (1), 32, Reduce, (60, 0), 0);
+ Add_Action (Table.States (1), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (1), 35, Reduce, (60, 0), 0);
+ Add_Action (Table.States (1), 36, Reduce, (60, 0), 0);
+ Add_Action (Table.States (1), 39, (60, 1), 10);
+ Add_Action (Table.States (1), 40, (71, 0), 11);
+ Table.States (1).Goto_List.Set_Capacity (10);
+ Add_Goto (Table.States (1), 43, 12);
+ Add_Goto (Table.States (1), 45, 13);
+ Add_Goto (Table.States (1), 46, 14);
+ Add_Goto (Table.States (1), 58, 15);
+ Add_Goto (Table.States (1), 59, 16);
+ Add_Goto (Table.States (1), 60, 17);
+ Add_Goto (Table.States (1), 61, 18);
+ Add_Goto (Table.States (1), 71, 19);
+ Add_Goto (Table.States (1), 72, 20);
+ Add_Goto (Table.States (1), 73, 21);
+ Table.States (1).Kernel := To_Vector ((0 => ((75, 0), 28, 1,
(32767, 0), 0)));
+ Table.States (1).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (72, 0), 0)));
+ Table.States (2).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (2), 41, Accept_It, (42, 0), 1);
+ Table.States (3).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (3), 5, Reduce, (52, 1), 1);
+ Add_Action (Table.States (3), 7, Reduce, (52, 1), 1);
+ Add_Action (Table.States (3), 9, Reduce, (52, 1), 1);
+ Add_Action (Table.States (3), 17, Reduce, (52, 1), 1);
+ Add_Action (Table.States (3), 21, Reduce, (52, 1), 1);
+ Add_Action (Table.States (3), 24, Reduce, (52, 1), 1);
+ Add_Action (Table.States (3), 28, (75, 0), 1);
+ Add_Action (Table.States (3), 41, Reduce, (52, 1), 1);
+ Table.States (3).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (3), 75, 22);
+ Table.States (3).Kernel := To_Vector ((((51, 1), 51, 2, (32767,
0), 0), ((52, 1), 51, 0, (52, 1),
+ 1)));
+ Table.States (3).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (52, 1), 1)));
+ Table.States (4).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (4), 5, (68, 1), 23);
+ Add_Action (Table.States (4), 7, (68, 3), 24);
+ Add_Action (Table.States (4), 9, (68, 6), 25);
+ Add_Action (Table.States (4), 17, (68, 5), 26);
+ Add_Action (Table.States (4), 21, Reduce, (68, 0), 0);
+ Add_Action (Table.States (4), 24, (68, 2), 27);
+ Add_Action (Table.States (4), 41, Reduce, (68, 0), 0);
+ Table.States (4).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (4), 68, 28);
+ Table.States (4).Kernel := To_Vector ((0 => ((50, 0), 52, 0,
(68, 0), 0)));
+ Table.States (4).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (68, 0), 0)));
+ Table.States (5).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (5), (5, 7, 9, 17, 21, 24, 28, 41), (51,
0), 1);
+ Table.States (5).Kernel := To_Vector ((0 => ((51, 0), 75, 0,
(51, 0), 1)));
+ Table.States (5).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (51, 0), 1)));
+ Table.States (6).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (6), 16, (43, 0), 29);
+ Table.States (6).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (6), 43, 30);
+ Table.States (6).Kernel := To_Vector ((0 => ((59, 0), 12, 2,
(32767, 0), 0)));
+ Table.States (6).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (43, 0), 16, 29)));
+ Table.States (7).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (7), 16, (43, 0), 29);
+ Table.States (7).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (7), 43, 31);
+ Table.States (7).Kernel := To_Vector ((0 => ((59, 1), 13, 2,
(32767, 0), 0)));
+ Table.States (7).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (43, 0), 16, 29)));
+ Table.States (8).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (8), 12, (59, 0), 32);
+ Add_Action (Table.States (8), 13, (59, 1), 33);
+ Add_Action (Table.States (8), 16, (43, 0), 34);
+ Add_Action (Table.States (8), 21, (45, 0), 9);
+ Add_Action (Table.States (8), 23, (73, 1), 35);
+ Add_Conflict (Table.States (8), 23, (60, 0), 0);
+ Add_Action (Table.States (8), 29, Reduce, (60, 0), 0);
+ Add_Action (Table.States (8), 32, Reduce, (60, 0), 0);
+ Add_Action (Table.States (8), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (8), 35, Reduce, (60, 0), 0);
+ Add_Action (Table.States (8), 39, (60, 1), 36);
+ Add_Action (Table.States (8), 40, (71, 0), 37);
+ Table.States (8).Goto_List.Set_Capacity (10);
+ Add_Goto (Table.States (8), 43, 38);
+ Add_Goto (Table.States (8), 45, 39);
+ Add_Goto (Table.States (8), 46, 40);
+ Add_Goto (Table.States (8), 58, 41);
+ Add_Goto (Table.States (8), 59, 42);
+ Add_Goto (Table.States (8), 60, 43);
+ Add_Goto (Table.States (8), 61, 44);
+ Add_Goto (Table.States (8), 71, 45);
+ Add_Goto (Table.States (8), 72, 46);
+ Add_Goto (Table.States (8), 73, 47);
+ Table.States (8).Kernel := To_Vector ((((43, 0), 16, 1, (32767,
0), 0), ((73, 1), 16, 1, (32767, 0),
+ 0)));
+ Table.States (8).Minimal_Complete_Actions := To_Vector (((Reduce,
(72, 0), 0), (Shift, (73, 1), 23,
+ 35)));
+ Table.States (9).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (9), (1 => 35), (45, 0), 1);
+ Table.States (9).Kernel := To_Vector ((0 => ((45, 0), 21, 0,
(45, 0), 1)));
+ Table.States (9).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (45, 0), 1)));
+ Table.States (10).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (10), (29, 32, 33, 35, 36), (60, 1), 1);
+ Table.States (10).Kernel := To_Vector ((0 => ((60, 1), 39, 0,
(60, 1), 1)));
+ Table.States (10).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (60, 1), 1)));
+ Table.States (11).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (11), (29, 32, 36), (71, 0), 1);
+ Table.States (11).Kernel := To_Vector ((0 => ((71, 0), 40, 0,
(71, 0), 1)));
+ Table.States (11).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (71, 0), 1)));
+ Table.States (12).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (12), (29, 32, 36), (73, 2), 1);
+ Table.States (12).Kernel := To_Vector ((0 => ((73, 2), 43, 0,
(73, 2), 1)));
+ Table.States (12).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (73, 2), 1)));
+ Table.States (13).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (13), 35, (46, 0), 48);
+ Table.States (13).Kernel := To_Vector ((((46, 0), 45, 2, (32767,
0), 0), ((46, 1), 45, 5, (32767, 0),
+ 0)));
+ Table.States (13).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (46, 0), 35, 48)));
+ Table.States (14).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (14), (29, 32, 36), (71, 3), 1);
+ Table.States (14).Kernel := To_Vector ((0 => ((71, 3), 46, 0,
(71, 3), 1)));
+ Table.States (14).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (71, 3), 1)));
+ Table.States (15).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (15), 29, (58, 1), 49);
+ Add_Action (Table.States (15), 32, Reduce, (72, 0), 1);
+ Add_Action (Table.States (15), 36, Reduce, (72, 0), 1);
+ Table.States (15).Kernel := To_Vector ((((58, 1), 58, 1, (32767,
0), 0), ((72, 0), 58, 0, (72, 0),
+ 1)));
+ Table.States (15).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (72, 0), 1)));
+ Table.States (16).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (16), (29, 32, 36), (71, 2), 1);
+ Table.States (16).Kernel := To_Vector ((0 => ((71, 2), 59, 0,
(71, 2), 1)));
+ Table.States (16).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (71, 2), 1)));
+ Table.States (17).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (17), (29, 32, 33, 35, 36), (61, 0), 1);
+ Table.States (17).Kernel := To_Vector ((0 => ((61, 0), 60, 0,
(61, 0), 1)));
+ Table.States (17).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (61, 0), 1)));
+ Table.States (18).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (18), 29, Reduce, (71, 1), 1);
+ Add_Action (Table.States (18), 32, Reduce, (71, 1), 1);
+ Add_Action (Table.States (18), 33, (61, 1), 50);
+ Add_Action (Table.States (18), 35, Reduce, (45, 1), 1);
+ Add_Action (Table.States (18), 36, Reduce, (71, 1), 1);
+ Table.States (18).Kernel := To_Vector ((((45, 1), 61, 0, (45,
1), 1), ((61, 1), 61, 2, (32767, 0),
+ 0), ((71, 1), 61, 0, (71, 1), 1)));
+ Table.States (18).Minimal_Complete_Actions := To_Vector (((Reduce,
(45, 1), 1), (Reduce, (71, 1), 1)));
+ Table.States (19).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (19), (29, 32, 36), (73, 0), 1);
+ Table.States (19).Kernel := To_Vector ((0 => ((73, 0), 71, 0,
(73, 0), 1)));
+ Table.States (19).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (73, 0), 1)));
+ Table.States (20).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (20), 32, (72, 1), 51);
+ Add_Action (Table.States (20), 36, (75, 0), 52);
+ Table.States (20).Kernel := To_Vector ((((72, 1), 72, 1, (32767,
0), 0), ((75, 0), 72, 1, (32767, 0),
+ 0)));
+ Table.States (20).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (75, 0), 36, 52)));
+ Table.States (21).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (21), (29, 32, 36), (58, 0), 1);
+ Table.States (21).Kernel := To_Vector ((0 => ((58, 0), 73, 0,
(58, 0), 1)));
+ Table.States (21).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (58, 0), 1)));
+ Table.States (22).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (22), (5, 7, 9, 17, 21, 24, 28, 41), (51,
1), 2);
+ Table.States (22).Kernel := To_Vector ((0 => ((51, 1), 75, 0,
(51, 1), 2)));
+ Table.States (22).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (51, 1), 2)));
+ Table.States (23).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (23), (21, 41), (68, 1), 1);
+ Table.States (23).Kernel := To_Vector ((0 => ((68, 1), 5, 0,
(68, 1), 1)));
+ Table.States (23).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (68, 1), 1)));
+ Table.States (24).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (24), 17, (68, 4), 53);
+ Add_Action (Table.States (24), 21, Reduce, (68, 3), 1);
+ Add_Action (Table.States (24), 41, Reduce, (68, 3), 1);
+ Table.States (24).Kernel := To_Vector ((((68, 3), 7, 0, (68, 3),
1), ((68, 4), 7, 1, (32767, 0),
+ 0)));
+ Table.States (24).Minimal_Complete_Actions := To_Vector (((Reduce,
(68, 3), 1), (Shift, (68, 4), 17,
+ 53)));
+ Table.States (25).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (25), (21, 41), (68, 6), 1);
+ Table.States (25).Kernel := To_Vector ((0 => ((68, 6), 9, 0,
(68, 6), 1)));
+ Table.States (25).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (68, 6), 1)));
+ Table.States (26).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (26), (21, 41), (68, 5), 1);
+ Table.States (26).Kernel := To_Vector ((0 => ((68, 5), 17, 0,
(68, 5), 1)));
+ Table.States (26).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (68, 5), 1)));
+ Table.States (27).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (27), (21, 41), (68, 2), 1);
+ Table.States (27).Kernel := To_Vector ((0 => ((68, 2), 24, 0,
(68, 2), 1)));
+ Table.States (27).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (68, 2), 1)));
+ Table.States (28).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (28), 21, (67, 0), 54);
+ Add_Action (Table.States (28), 41, Reduce, (66, 0), 0);
+ Table.States (28).Goto_List.Set_Capacity (3);
+ Add_Goto (Table.States (28), 66, 55);
+ Add_Goto (Table.States (28), 67, 56);
+ Add_Goto (Table.States (28), 70, 57);
+ Table.States (28).Kernel := To_Vector ((0 => ((50, 0), 68, 0,
(66, 0), 0)));
+ Table.States (28).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (66, 0), 0)));
+ Table.States (29).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (29), 12, (59, 0), 32);
+ Add_Action (Table.States (29), 13, (59, 1), 33);
+ Add_Action (Table.States (29), 16, (43, 0), 34);
+ Add_Action (Table.States (29), 21, (45, 0), 9);
+ Add_Action (Table.States (29), 23, Reduce, (60, 0), 0);
+ Add_Action (Table.States (29), 29, Reduce, (60, 0), 0);
+ Add_Action (Table.States (29), 32, Reduce, (60, 0), 0);
+ Add_Action (Table.States (29), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (29), 35, Reduce, (60, 0), 0);
+ Add_Action (Table.States (29), 39, (60, 1), 36);
+ Add_Action (Table.States (29), 40, (71, 0), 37);
+ Table.States (29).Goto_List.Set_Capacity (10);
+ Add_Goto (Table.States (29), 43, 38);
+ Add_Goto (Table.States (29), 45, 39);
+ Add_Goto (Table.States (29), 46, 40);
+ Add_Goto (Table.States (29), 58, 41);
+ Add_Goto (Table.States (29), 59, 42);
+ Add_Goto (Table.States (29), 60, 43);
+ Add_Goto (Table.States (29), 61, 44);
+ Add_Goto (Table.States (29), 71, 45);
+ Add_Goto (Table.States (29), 72, 46);
+ Add_Goto (Table.States (29), 73, 47);
+ Table.States (29).Kernel := To_Vector ((0 => ((43, 0), 16, 1,
(32767, 0), 0)));
+ Table.States (29).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (72, 0), 0)));
+ Table.States (30).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (30), (29, 32, 36), (59, 0), 2);
+ Table.States (30).Kernel := To_Vector ((0 => ((59, 0), 43, 0,
(59, 0), 2)));
+ Table.States (30).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (59, 0), 2)));
+ Table.States (31).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (31), (29, 32, 36), (59, 1), 2);
+ Table.States (31).Kernel := To_Vector ((0 => ((59, 1), 43, 0,
(59, 1), 2)));
+ Table.States (31).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (59, 1), 2)));
+ Table.States (32).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (32), 16, (43, 0), 58);
+ Table.States (32).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (32), 43, 59);
+ Table.States (32).Kernel := To_Vector ((0 => ((59, 0), 12, 2,
(32767, 0), 0)));
+ Table.States (32).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (43, 0), 16, 58)));
+ Table.States (33).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (33), 16, (43, 0), 58);
+ Table.States (33).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (33), 43, 60);
+ Table.States (33).Kernel := To_Vector ((0 => ((59, 1), 13, 2,
(32767, 0), 0)));
+ Table.States (33).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (43, 0), 16, 58)));
+ Table.States (34).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (34), 12, (59, 0), 32);
+ Add_Action (Table.States (34), 13, (59, 1), 33);
+ Add_Action (Table.States (34), 16, (43, 0), 34);
+ Add_Action (Table.States (34), 21, (45, 0), 9);
+ Add_Action (Table.States (34), 23, (73, 1), 61);
+ Add_Conflict (Table.States (34), 23, (60, 0), 0);
+ Add_Action (Table.States (34), 29, Reduce, (60, 0), 0);
+ Add_Action (Table.States (34), 32, Reduce, (60, 0), 0);
+ Add_Action (Table.States (34), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (34), 35, Reduce, (60, 0), 0);
+ Add_Action (Table.States (34), 39, (60, 1), 36);
+ Add_Action (Table.States (34), 40, (71, 0), 37);
+ Table.States (34).Goto_List.Set_Capacity (10);
+ Add_Goto (Table.States (34), 43, 38);
+ Add_Goto (Table.States (34), 45, 39);
+ Add_Goto (Table.States (34), 46, 40);
+ Add_Goto (Table.States (34), 58, 41);
+ Add_Goto (Table.States (34), 59, 42);
+ Add_Goto (Table.States (34), 60, 43);
+ Add_Goto (Table.States (34), 61, 44);
+ Add_Goto (Table.States (34), 71, 45);
+ Add_Goto (Table.States (34), 72, 62);
+ Add_Goto (Table.States (34), 73, 47);
+ Table.States (34).Kernel := To_Vector ((((43, 0), 16, 1, (32767,
0), 0), ((73, 1), 16, 1, (32767, 0),
+ 0)));
+ Table.States (34).Minimal_Complete_Actions := To_Vector (((Reduce,
(72, 0), 0), (Shift, (73, 1), 23,
+ 61)));
+ Table.States (35).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (35), (29, 32, 36), (73, 1), 2);
+ Table.States (35).Kernel := To_Vector ((0 => ((73, 1), 23, 0,
(73, 1), 2)));
+ Table.States (35).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (73, 1), 2)));
+ Table.States (36).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (36), (23, 29, 32, 33, 35), (60, 1), 1);
+ Table.States (36).Kernel := To_Vector ((0 => ((60, 1), 39, 0,
(60, 1), 1)));
+ Table.States (36).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (60, 1), 1)));
+ Table.States (37).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (37), (23, 29, 32), (71, 0), 1);
+ Table.States (37).Kernel := To_Vector ((0 => ((71, 0), 40, 0,
(71, 0), 1)));
+ Table.States (37).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (71, 0), 1)));
+ Table.States (38).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (38), (23, 29, 32), (73, 2), 1);
+ Table.States (38).Kernel := To_Vector ((0 => ((73, 2), 43, 0,
(73, 2), 1)));
+ Table.States (38).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (73, 2), 1)));
+ Table.States (39).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (39), 35, (46, 0), 63);
+ Table.States (39).Kernel := To_Vector ((((46, 0), 45, 2, (32767,
0), 0), ((46, 1), 45, 5, (32767, 0),
+ 0)));
+ Table.States (39).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (46, 0), 35, 63)));
+ Table.States (40).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (40), (23, 29, 32), (71, 3), 1);
+ Table.States (40).Kernel := To_Vector ((0 => ((71, 3), 46, 0,
(71, 3), 1)));
+ Table.States (40).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (71, 3), 1)));
+ Table.States (41).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (41), 23, Reduce, (72, 0), 1);
+ Add_Action (Table.States (41), 29, (58, 1), 64);
+ Add_Action (Table.States (41), 32, Reduce, (72, 0), 1);
+ Table.States (41).Kernel := To_Vector ((((58, 1), 58, 1, (32767,
0), 0), ((72, 0), 58, 0, (72, 0),
+ 1)));
+ Table.States (41).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (72, 0), 1)));
+ Table.States (42).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (42), (23, 29, 32), (71, 2), 1);
+ Table.States (42).Kernel := To_Vector ((0 => ((71, 2), 59, 0,
(71, 2), 1)));
+ Table.States (42).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (71, 2), 1)));
+ Table.States (43).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (43), (23, 29, 32, 33, 35), (61, 0), 1);
+ Table.States (43).Kernel := To_Vector ((0 => ((61, 0), 60, 0,
(61, 0), 1)));
+ Table.States (43).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (61, 0), 1)));
+ Table.States (44).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (44), 23, Reduce, (71, 1), 1);
+ Add_Action (Table.States (44), 29, Reduce, (71, 1), 1);
+ Add_Action (Table.States (44), 32, Reduce, (71, 1), 1);
+ Add_Action (Table.States (44), 33, (61, 1), 65);
+ Add_Action (Table.States (44), 35, Reduce, (45, 1), 1);
+ Table.States (44).Kernel := To_Vector ((((45, 1), 61, 0, (45,
1), 1), ((61, 1), 61, 2, (32767, 0),
+ 0), ((71, 1), 61, 0, (71, 1), 1)));
+ Table.States (44).Minimal_Complete_Actions := To_Vector (((Reduce,
(45, 1), 1), (Reduce, (71, 1), 1)));
+ Table.States (45).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (45), (23, 29, 32), (73, 0), 1);
+ Table.States (45).Kernel := To_Vector ((0 => ((73, 0), 71, 0,
(73, 0), 1)));
+ Table.States (45).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (73, 0), 1)));
+ Table.States (46).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (46), 23, (43, 0), 66);
+ Add_Action (Table.States (46), 32, (72, 1), 67);
+ Table.States (46).Kernel := To_Vector ((((43, 0), 72, 1, (32767,
0), 0), ((72, 1), 72, 1, (32767, 0),
+ 0)));
+ Table.States (46).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (43, 0), 23, 66)));
+ Table.States (47).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (47), (23, 29, 32), (58, 0), 1);
+ Table.States (47).Kernel := To_Vector ((0 => ((58, 0), 73, 0,
(58, 0), 1)));
+ Table.States (47).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (58, 0), 1)));
+ Table.States (48).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (48), 39, (46, 0), 68);
+ Table.States (48).Kernel := To_Vector ((((46, 0), 35, 1, (32767,
0), 0), ((46, 1), 35, 4, (32767, 0),
+ 0)));
+ Table.States (48).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (46, 0), 39, 68)));
+ Table.States (49).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (49), 12, (59, 0), 6);
+ Add_Action (Table.States (49), 13, (59, 1), 7);
+ Add_Action (Table.States (49), 16, (43, 0), 8);
+ Add_Action (Table.States (49), 21, (45, 0), 9);
+ Add_Action (Table.States (49), 29, Reduce, (60, 0), 0);
+ Add_Action (Table.States (49), 32, Reduce, (60, 0), 0);
+ Add_Action (Table.States (49), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (49), 35, Reduce, (60, 0), 0);
+ Add_Action (Table.States (49), 36, Reduce, (60, 0), 0);
+ Add_Action (Table.States (49), 39, (60, 1), 10);
+ Add_Action (Table.States (49), 40, (71, 0), 11);
+ Table.States (49).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (49), 43, 12);
+ Add_Goto (Table.States (49), 45, 13);
+ Add_Goto (Table.States (49), 46, 14);
+ Add_Goto (Table.States (49), 59, 16);
+ Add_Goto (Table.States (49), 60, 17);
+ Add_Goto (Table.States (49), 61, 18);
+ Add_Goto (Table.States (49), 71, 19);
+ Add_Goto (Table.States (49), 73, 69);
+ Table.States (49).Kernel := To_Vector ((0 => ((58, 1), 29, 0,
(73, 0), 0)));
+ Table.States (49).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (73, 0), 0)));
+ end Subr_1;
+ procedure Subr_2
+ is begin
+ Table.States (50).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (50), 39, (61, 1), 70);
+ Table.States (50).Kernel := To_Vector ((0 => ((61, 1), 33, 1,
(32767, 0), 0)));
+ Table.States (50).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (61, 1), 39, 70)));
+ Table.States (51).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (51), 12, (59, 0), 6);
+ Add_Action (Table.States (51), 13, (59, 1), 7);
+ Add_Action (Table.States (51), 16, (43, 0), 8);
+ Add_Action (Table.States (51), 21, (45, 0), 9);
+ Add_Action (Table.States (51), 29, Reduce, (60, 0), 0);
+ Add_Action (Table.States (51), 32, Reduce, (60, 0), 0);
+ Add_Action (Table.States (51), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (51), 35, Reduce, (60, 0), 0);
+ Add_Action (Table.States (51), 36, Reduce, (60, 0), 0);
+ Add_Action (Table.States (51), 39, (60, 1), 10);
+ Add_Action (Table.States (51), 40, (71, 0), 11);
+ Table.States (51).Goto_List.Set_Capacity (9);
+ Add_Goto (Table.States (51), 43, 12);
+ Add_Goto (Table.States (51), 45, 13);
+ Add_Goto (Table.States (51), 46, 14);
+ Add_Goto (Table.States (51), 58, 71);
+ Add_Goto (Table.States (51), 59, 16);
+ Add_Goto (Table.States (51), 60, 17);
+ Add_Goto (Table.States (51), 61, 18);
+ Add_Goto (Table.States (51), 71, 19);
+ Add_Goto (Table.States (51), 73, 21);
+ Table.States (51).Kernel := To_Vector ((0 => ((72, 1), 32, 0,
(58, 1), 0)));
+ Table.States (51).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (58, 1), 0)));
+ Table.States (52).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (52), (5, 7, 9, 17, 21, 24, 28, 41), (75,
0), 3);
+ Table.States (52).Kernel := To_Vector ((0 => ((75, 0), 36, 0,
(75, 0), 3)));
+ Table.States (52).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (75, 0), 3)));
+ Table.States (53).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (53), (21, 41), (68, 4), 2);
+ Table.States (53).Kernel := To_Vector ((0 => ((68, 4), 17, 0,
(68, 4), 2)));
+ Table.States (53).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (68, 4), 2)));
+ Table.States (54).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (54), 11, Reduce, (60, 0), 0);
+ Add_Action (Table.States (54), 15, Reduce, (60, 0), 0);
+ Add_Action (Table.States (54), 39, (60, 1), 72);
+ Table.States (54).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (54), 60, 73);
+ Table.States (54).Kernel := To_Vector ((((67, 0), 21, 5, (32767,
0), 0), ((70, 0), 21, 3, (32767, 0),
+ 0)));
+ Table.States (54).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (60, 0), 0)));
+ Table.States (55).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (55), (1 => 41), (50, 0), 3);
+ Table.States (55).Kernel := To_Vector ((0 => ((50, 0), 66, 0,
(50, 0), 3)));
+ Table.States (55).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (50, 0), 3)));
+ Table.States (56).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (56), (1 => 41), (66, 2), 1);
+ Table.States (56).Kernel := To_Vector ((0 => ((66, 2), 67, 0,
(66, 2), 1)));
+ Table.States (56).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (66, 2), 1)));
+ Table.States (57).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (57), (1 => 41), (66, 1), 1);
+ Table.States (57).Kernel := To_Vector ((0 => ((66, 1), 70, 0,
(66, 1), 1)));
+ Table.States (57).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (66, 1), 1)));
+ Table.States (58).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (58), 12, (59, 0), 32);
+ Add_Action (Table.States (58), 13, (59, 1), 33);
+ Add_Action (Table.States (58), 16, (43, 0), 34);
+ Add_Action (Table.States (58), 21, (45, 0), 9);
+ Add_Action (Table.States (58), 23, Reduce, (60, 0), 0);
+ Add_Action (Table.States (58), 29, Reduce, (60, 0), 0);
+ Add_Action (Table.States (58), 32, Reduce, (60, 0), 0);
+ Add_Action (Table.States (58), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (58), 35, Reduce, (60, 0), 0);
+ Add_Action (Table.States (58), 39, (60, 1), 36);
+ Add_Action (Table.States (58), 40, (71, 0), 37);
+ Table.States (58).Goto_List.Set_Capacity (10);
+ Add_Goto (Table.States (58), 43, 38);
+ Add_Goto (Table.States (58), 45, 39);
+ Add_Goto (Table.States (58), 46, 40);
+ Add_Goto (Table.States (58), 58, 41);
+ Add_Goto (Table.States (58), 59, 42);
+ Add_Goto (Table.States (58), 60, 43);
+ Add_Goto (Table.States (58), 61, 44);
+ Add_Goto (Table.States (58), 71, 45);
+ Add_Goto (Table.States (58), 72, 62);
+ Add_Goto (Table.States (58), 73, 47);
+ Table.States (58).Kernel := To_Vector ((0 => ((43, 0), 16, 1,
(32767, 0), 0)));
+ Table.States (58).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (72, 0), 0)));
+ Table.States (59).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (59), (23, 29, 32), (59, 0), 2);
+ Table.States (59).Kernel := To_Vector ((0 => ((59, 0), 43, 0,
(59, 0), 2)));
+ Table.States (59).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (59, 0), 2)));
+ Table.States (60).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (60), (23, 29, 32), (59, 1), 2);
+ Table.States (60).Kernel := To_Vector ((0 => ((59, 1), 43, 0,
(59, 1), 2)));
+ Table.States (60).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (59, 1), 2)));
+ Table.States (61).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (61), (23, 29, 32), (73, 1), 2);
+ Table.States (61).Kernel := To_Vector ((0 => ((73, 1), 23, 0,
(73, 1), 2)));
+ Table.States (61).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (73, 1), 2)));
+ Table.States (62).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (62), 23, (43, 0), 74);
+ Add_Action (Table.States (62), 32, (72, 1), 67);
+ Table.States (62).Kernel := To_Vector ((((43, 0), 72, 1, (32767,
0), 0), ((72, 1), 72, 1, (32767, 0),
+ 0)));
+ Table.States (62).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (43, 0), 23, 74)));
+ Table.States (63).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (63), 39, (46, 0), 75);
+ Table.States (63).Kernel := To_Vector ((((46, 0), 35, 1, (32767,
0), 0), ((46, 1), 35, 4, (32767, 0),
+ 0)));
+ Table.States (63).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (46, 0), 39, 75)));
+ Table.States (64).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (64), 12, (59, 0), 32);
+ Add_Action (Table.States (64), 13, (59, 1), 33);
+ Add_Action (Table.States (64), 16, (43, 0), 34);
+ Add_Action (Table.States (64), 21, (45, 0), 9);
+ Add_Action (Table.States (64), 23, Reduce, (60, 0), 0);
+ Add_Action (Table.States (64), 29, Reduce, (60, 0), 0);
+ Add_Action (Table.States (64), 32, Reduce, (60, 0), 0);
+ Add_Action (Table.States (64), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (64), 35, Reduce, (60, 0), 0);
+ Add_Action (Table.States (64), 39, (60, 1), 36);
+ Add_Action (Table.States (64), 40, (71, 0), 37);
+ Table.States (64).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (64), 43, 38);
+ Add_Goto (Table.States (64), 45, 39);
+ Add_Goto (Table.States (64), 46, 40);
+ Add_Goto (Table.States (64), 59, 42);
+ Add_Goto (Table.States (64), 60, 43);
+ Add_Goto (Table.States (64), 61, 44);
+ Add_Goto (Table.States (64), 71, 45);
+ Add_Goto (Table.States (64), 73, 76);
+ Table.States (64).Kernel := To_Vector ((0 => ((58, 1), 29, 0,
(73, 0), 0)));
+ Table.States (64).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (73, 0), 0)));
+ Table.States (65).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (65), 39, (61, 1), 77);
+ Table.States (65).Kernel := To_Vector ((0 => ((61, 1), 33, 1,
(32767, 0), 0)));
+ Table.States (65).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (61, 1), 39, 77)));
+ Table.States (66).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (66), (29, 32, 36), (43, 0), 3);
+ Table.States (66).Kernel := To_Vector ((0 => ((43, 0), 23, 0,
(43, 0), 3)));
+ Table.States (66).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (43, 0), 3)));
+ Table.States (67).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (67), 12, (59, 0), 32);
+ Add_Action (Table.States (67), 13, (59, 1), 33);
+ Add_Action (Table.States (67), 16, (43, 0), 34);
+ Add_Action (Table.States (67), 21, (45, 0), 9);
+ Add_Action (Table.States (67), 23, Reduce, (60, 0), 0);
+ Add_Action (Table.States (67), 29, Reduce, (60, 0), 0);
+ Add_Action (Table.States (67), 32, Reduce, (60, 0), 0);
+ Add_Action (Table.States (67), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (67), 35, Reduce, (60, 0), 0);
+ Add_Action (Table.States (67), 39, (60, 1), 36);
+ Add_Action (Table.States (67), 40, (71, 0), 37);
+ Table.States (67).Goto_List.Set_Capacity (9);
+ Add_Goto (Table.States (67), 43, 38);
+ Add_Goto (Table.States (67), 45, 39);
+ Add_Goto (Table.States (67), 46, 40);
+ Add_Goto (Table.States (67), 58, 78);
+ Add_Goto (Table.States (67), 59, 42);
+ Add_Goto (Table.States (67), 60, 43);
+ Add_Goto (Table.States (67), 61, 44);
+ Add_Goto (Table.States (67), 71, 45);
+ Add_Goto (Table.States (67), 73, 47);
+ Table.States (67).Kernel := To_Vector ((0 => ((72, 1), 32, 0,
(58, 1), 0)));
+ Table.States (67).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (58, 1), 0)));
+ Table.States (68).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (68), 16, (46, 1), 79);
+ Add_Action (Table.States (68), 29, Reduce, (46, 0), 3);
+ Add_Action (Table.States (68), 32, Reduce, (46, 0), 3);
+ Add_Action (Table.States (68), 36, Reduce, (46, 0), 3);
+ Table.States (68).Kernel := To_Vector ((((46, 0), 39, 0, (46,
0), 3), ((46, 1), 39, 3, (32767, 0),
+ 0)));
+ Table.States (68).Minimal_Complete_Actions := To_Vector (((Reduce,
(46, 0), 3), (Shift, (46, 1), 16,
+ 79)));
+ Table.States (69).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (69), (29, 32, 36), (58, 1), 3);
+ Table.States (69).Kernel := To_Vector ((0 => ((58, 1), 73, 0,
(58, 1), 3)));
+ Table.States (69).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (58, 1), 3)));
+ Table.States (70).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (70), (29, 32, 33, 35, 36), (61, 1), 3);
+ Table.States (70).Kernel := To_Vector ((0 => ((61, 1), 39, 0,
(61, 1), 3)));
+ Table.States (70).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (61, 1), 3)));
+ Table.States (71).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (71), 29, (58, 1), 49);
+ Add_Action (Table.States (71), 32, Reduce, (72, 1), 3);
+ Add_Action (Table.States (71), 36, Reduce, (72, 1), 3);
+ Table.States (71).Kernel := To_Vector ((((58, 1), 58, 1, (32767,
0), 0), ((72, 1), 58, 0, (72, 1),
+ 3)));
+ Table.States (71).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (72, 1), 3)));
+ Table.States (72).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (72), (11, 15), (60, 1), 1);
+ Table.States (72).Kernel := To_Vector ((0 => ((60, 1), 39, 0,
(60, 1), 1)));
+ Table.States (72).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (60, 1), 1)));
+ Table.States (73).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (73), 11, (67, 0), 80);
+ Add_Action (Table.States (73), 15, (70, 0), 81);
+ Table.States (73).Kernel := To_Vector ((((67, 0), 60, 5, (32767,
0), 0), ((70, 0), 60, 3, (32767, 0),
+ 0)));
+ Table.States (73).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (70, 0), 15, 81)));
+ Table.States (74).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (74), (23, 29, 32), (43, 0), 3);
+ Table.States (74).Kernel := To_Vector ((0 => ((43, 0), 23, 0,
(43, 0), 3)));
+ Table.States (74).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (43, 0), 3)));
+ Table.States (75).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (75), 16, (46, 1), 82);
+ Add_Action (Table.States (75), 23, Reduce, (46, 0), 3);
+ Add_Action (Table.States (75), 29, Reduce, (46, 0), 3);
+ Add_Action (Table.States (75), 32, Reduce, (46, 0), 3);
+ Table.States (75).Kernel := To_Vector ((((46, 0), 39, 0, (46,
0), 3), ((46, 1), 39, 3, (32767, 0),
+ 0)));
+ Table.States (75).Minimal_Complete_Actions := To_Vector (((Reduce,
(46, 0), 3), (Shift, (46, 1), 16,
+ 82)));
+ Table.States (76).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (76), (23, 29, 32), (58, 1), 3);
+ Table.States (76).Kernel := To_Vector ((0 => ((58, 1), 73, 0,
(58, 1), 3)));
+ Table.States (76).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (58, 1), 3)));
+ Table.States (77).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (77), (23, 29, 32, 33, 35), (61, 1), 3);
+ Table.States (77).Kernel := To_Vector ((0 => ((61, 1), 39, 0,
(61, 1), 3)));
+ Table.States (77).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (61, 1), 3)));
+ Table.States (78).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (78), 23, Reduce, (72, 1), 3);
+ Add_Action (Table.States (78), 29, (58, 1), 64);
+ Add_Action (Table.States (78), 32, Reduce, (72, 1), 3);
+ Table.States (78).Kernel := To_Vector ((((58, 1), 58, 1, (32767,
0), 0), ((72, 1), 58, 0, (72, 1),
+ 3)));
+ Table.States (78).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (72, 1), 3)));
+ Table.States (79).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (79), 40, (46, 1), 83);
+ Table.States (79).Kernel := To_Vector ((0 => ((46, 1), 16, 2,
(32767, 0), 0)));
+ Table.States (79).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (46, 1), 40, 83)));
+ Table.States (80).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (80), 40, (67, 0), 84);
+ Table.States (80).Kernel := To_Vector ((0 => ((67, 0), 11, 4,
(32767, 0), 0)));
+ Table.States (80).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (67, 0), 40, 84)));
+ Table.States (81).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (81), 8, (47, 0), 85);
+ Add_Action (Table.States (81), 10, Reduce, (55, 0), 0);
+ Add_Action (Table.States (81), 14, (44, 0), 86);
+ Add_Action (Table.States (81), 18, (69, 4), 87);
+ Add_Action (Table.States (81), 20, (63, 0), 88);
+ Add_Action (Table.States (81), 25, (74, 0), 89);
+ Add_Action (Table.States (81), 39, (69, 0), 90);
+ Table.States (81).Goto_List.Set_Capacity (11);
+ Add_Goto (Table.States (81), 44, 91);
+ Add_Goto (Table.States (81), 47, 92);
+ Add_Goto (Table.States (81), 53, 93);
+ Add_Goto (Table.States (81), 54, 94);
+ Add_Goto (Table.States (81), 55, 95);
+ Add_Goto (Table.States (81), 62, 96);
+ Add_Goto (Table.States (81), 63, 97);
+ Add_Goto (Table.States (81), 64, 98);
+ Add_Goto (Table.States (81), 65, 99);
+ Add_Goto (Table.States (81), 69, 100);
+ Add_Goto (Table.States (81), 74, 101);
+ Table.States (81).Kernel := To_Vector ((0 => ((70, 0), 15, 2,
(32767, 0), 0)));
+ Table.States (81).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (55, 0), 0)));
+ Table.States (82).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (82), 40, (46, 1), 102);
+ Table.States (82).Kernel := To_Vector ((0 => ((46, 1), 16, 2,
(32767, 0), 0)));
+ Table.States (82).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (46, 1), 40, 102)));
+ Table.States (83).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (83), 23, (46, 1), 103);
+ Table.States (83).Kernel := To_Vector ((0 => ((46, 1), 40, 1,
(32767, 0), 0)));
+ Table.States (83).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (46, 1), 23, 103)));
+ Table.States (84).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (84), 15, (67, 0), 104);
+ Table.States (84).Kernel := To_Vector ((0 => ((67, 0), 40, 3,
(32767, 0), 0)));
+ Table.States (84).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (67, 0), 15, 104)));
+ Table.States (85).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (85), 15, Reduce, (60, 0), 0);
+ Add_Action (Table.States (85), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (85), 39, (60, 1), 105);
+ Table.States (85).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (85), 60, 106);
+ Add_Goto (Table.States (85), 61, 107);
+ Table.States (85).Kernel := To_Vector ((0 => ((47, 0), 8, 4,
(32767, 0), 0)));
+ Table.States (85).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (61, 0), 0)));
+ Table.States (86).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (86), 12, (44, 3), 108);
+ Add_Action (Table.States (86), 39, (44, 0), 109);
+ Table.States (86).Kernel := To_Vector ((((44, 0), 14, 3, (32767,
0), 0), ((44, 1), 14, 5, (32767, 0),
+ 0), ((44, 2), 14, 7, (32767, 0), 0), ((44, 3), 14, 6, (32767,
0), 0)));
+ Table.States (86).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (44, 0), 39, 109)));
+ Table.States (87).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (87), 36, (69, 4), 110);
+ Table.States (87).Kernel := To_Vector ((0 => ((69, 4), 18, 1,
(32767, 0), 0)));
+ Table.States (87).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (69, 4), 36, 110)));
+ Table.States (88).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (88), 11, Reduce, (60, 0), 0);
+ Add_Action (Table.States (88), 15, Reduce, (60, 0), 0);
+ Add_Action (Table.States (88), 22, Reduce, (60, 0), 0);
+ Add_Action (Table.States (88), 39, (60, 1), 111);
+ Table.States (88).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (88), 60, 112);
+ Table.States (88).Kernel := To_Vector ((((63, 0), 20, 3, (32767,
0), 0), ((64, 0), 20, 4, (32767, 0),
+ 0), ((65, 0), 20, 2, (32767, 0), 0)));
+ Table.States (88).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (60, 0), 0)));
+ Table.States (89).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (89), 39, (74, 0), 113);
+ Table.States (89).Kernel := To_Vector ((0 => ((74, 0), 25, 5,
(32767, 0), 0)));
+ Table.States (89).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (74, 0), 39, 113)));
+ Table.States (90).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (90), 30, (69, 1), 114);
+ Add_Action (Table.States (90), 31, (69, 0), 115);
+ Table.States (90).Kernel := To_Vector ((((69, 0), 39, 2, (32767,
0), 0), ((69, 1), 39, 4, (32767, 0),
+ 0)));
+ Table.States (90).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (69, 0), 31, 115)));
+ Table.States (91).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (91), (8, 10, 14, 18, 20, 25, 39), (69,
2), 1);
+ Table.States (91).Kernel := To_Vector ((0 => ((69, 2), 44, 0,
(69, 2), 1)));
+ Table.States (91).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (69, 2), 1)));
+ Table.States (92).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (92), (8, 10, 14, 18, 20, 25, 39), (69,
3), 1);
+ Table.States (92).Kernel := To_Vector ((0 => ((69, 3), 47, 0,
(69, 3), 1)));
+ Table.States (92).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (69, 3), 1)));
+ Table.States (93).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (93), (8, 10, 14, 18, 20, 25, 39), (54,
0), 1);
+ Table.States (93).Kernel := To_Vector ((0 => ((54, 0), 53, 0,
(54, 0), 1)));
+ Table.States (93).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (54, 0), 1)));
+ Table.States (94).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (94), 8, (47, 0), 85);
+ Add_Action (Table.States (94), 10, Reduce, (55, 1), 1);
+ Add_Action (Table.States (94), 14, (44, 0), 86);
+ Add_Action (Table.States (94), 18, (69, 4), 87);
+ Add_Action (Table.States (94), 20, (63, 0), 88);
+ Add_Action (Table.States (94), 25, (74, 0), 89);
+ Add_Action (Table.States (94), 39, (69, 0), 90);
+ Table.States (94).Goto_List.Set_Capacity (9);
+ Add_Goto (Table.States (94), 44, 91);
+ Add_Goto (Table.States (94), 47, 92);
+ Add_Goto (Table.States (94), 53, 116);
+ Add_Goto (Table.States (94), 62, 96);
+ Add_Goto (Table.States (94), 63, 97);
+ Add_Goto (Table.States (94), 64, 98);
+ Add_Goto (Table.States (94), 65, 99);
+ Add_Goto (Table.States (94), 69, 100);
+ Add_Goto (Table.States (94), 74, 101);
+ Table.States (94).Kernel := To_Vector ((((54, 1), 54, 2, (32767,
0), 0), ((55, 1), 54, 0, (55, 1),
+ 1)));
+ Table.States (94).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (55, 1), 1)));
+ Table.States (95).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (95), 10, (70, 0), 117);
+ Table.States (95).Kernel := To_Vector ((0 => ((70, 0), 55, 2,
(32767, 0), 0)));
+ Table.States (95).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (70, 0), 10, 117)));
+ Table.States (96).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (96), (8, 10, 14, 18, 20, 25, 39), (53,
2), 1);
+ Table.States (96).Kernel := To_Vector ((0 => ((53, 2), 62, 0,
(53, 2), 1)));
+ Table.States (96).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (53, 2), 1)));
+ Table.States (97).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (97), (8, 10, 14, 18, 20, 25, 39), (62,
0), 1);
+ Table.States (97).Kernel := To_Vector ((0 => ((62, 0), 63, 0,
(62, 0), 1)));
+ Table.States (97).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (62, 0), 1)));
+ Table.States (98).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (98), (8, 10, 14, 18, 20, 25, 39), (62,
1), 1);
+ Table.States (98).Kernel := To_Vector ((0 => ((62, 1), 64, 0,
(62, 1), 1)));
+ Table.States (98).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (62, 1), 1)));
+ Table.States (99).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (99), (8, 10, 14, 18, 20, 25, 39), (62,
2), 1);
+ Table.States (99).Kernel := To_Vector ((0 => ((62, 2), 65, 0,
(62, 2), 1)));
+ Table.States (99).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (62, 2), 1)));
+ Table.States (100).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (100), (8, 10, 14, 18, 20, 25, 39), (53,
0), 1);
+ Table.States (100).Kernel := To_Vector ((0 => ((53, 0), 69, 0,
(53, 0), 1)));
+ Table.States (100).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (53, 0), 1)));
+ Table.States (101).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (101), (8, 10, 14, 18, 20, 25, 39), (53,
1), 1);
+ Table.States (101).Kernel := To_Vector ((0 => ((53, 1), 74, 0,
(53, 1), 1)));
+ Table.States (101).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (53, 1), 1)));
+ Table.States (102).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (102), 23, (46, 1), 118);
+ Table.States (102).Kernel := To_Vector ((0 => ((46, 1), 40, 1,
(32767, 0), 0)));
+ Table.States (102).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (46, 1), 23, 118)));
+ Table.States (103).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (103), (29, 32, 36), (46, 1), 6);
+ Table.States (103).Kernel := To_Vector ((0 => ((46, 1), 23, 0,
(46, 1), 6)));
+ Table.States (103).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (46, 1), 6)));
+ end Subr_2;
+ procedure Subr_3
+ is begin
+ Table.States (104).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (104), 8, (47, 0), 85);
+ Add_Action (Table.States (104), 10, Reduce, (55, 0), 0);
+ Add_Action (Table.States (104), 14, (44, 0), 86);
+ Add_Action (Table.States (104), 18, (69, 4), 87);
+ Add_Action (Table.States (104), 20, (63, 0), 88);
+ Add_Action (Table.States (104), 25, (74, 0), 89);
+ Add_Action (Table.States (104), 39, (69, 0), 90);
+ Table.States (104).Goto_List.Set_Capacity (11);
+ Add_Goto (Table.States (104), 44, 91);
+ Add_Goto (Table.States (104), 47, 92);
+ Add_Goto (Table.States (104), 53, 93);
+ Add_Goto (Table.States (104), 54, 94);
+ Add_Goto (Table.States (104), 55, 119);
+ Add_Goto (Table.States (104), 62, 96);
+ Add_Goto (Table.States (104), 63, 97);
+ Add_Goto (Table.States (104), 64, 98);
+ Add_Goto (Table.States (104), 65, 99);
+ Add_Goto (Table.States (104), 69, 100);
+ Add_Goto (Table.States (104), 74, 101);
+ Table.States (104).Kernel := To_Vector ((0 => ((67, 0), 15, 2,
(32767, 0), 0)));
+ Table.States (104).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (55, 0), 0)));
+ Table.States (105).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (105), (15, 33), (60, 1), 1);
+ Table.States (105).Kernel := To_Vector ((0 => ((60, 1), 39, 0,
(60, 1), 1)));
+ Table.States (105).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (60, 1), 1)));
+ Table.States (106).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (106), (15, 33), (61, 0), 1);
+ Table.States (106).Kernel := To_Vector ((0 => ((61, 0), 60, 0,
(61, 0), 1)));
+ Table.States (106).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (61, 0), 1)));
+ Table.States (107).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (107), 15, (47, 0), 120);
+ Add_Action (Table.States (107), 33, (61, 1), 121);
+ Table.States (107).Kernel := To_Vector ((((47, 0), 61, 4,
(32767, 0), 0), ((61, 1), 61, 2, (32767, 0),
+ 0)));
+ Table.States (107).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (47, 0), 15, 120)));
+ Table.States (108).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (108), 16, (44, 3), 122);
+ Table.States (108).Kernel := To_Vector ((0 => ((44, 3), 12, 5,
(32767, 0), 0)));
+ Table.States (108).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (44, 3), 16, 122)));
+ Table.States (109).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (109), 16, (44, 1), 123);
+ Add_Action (Table.States (109), 26, (44, 0), 124);
+ Table.States (109).Kernel := To_Vector ((((44, 0), 39, 2,
(32767, 0), 0), ((44, 1), 39, 4, (32767, 0),
+ 0), ((44, 2), 39, 6, (32767, 0), 0)));
+ Table.States (109).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (44, 0), 26, 124)));
+ Table.States (110).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (110), (8, 10, 14, 18, 20, 25, 39), (69,
4), 2);
+ Table.States (110).Kernel := To_Vector ((0 => ((69, 4), 36, 0,
(69, 4), 2)));
+ Table.States (110).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (69, 4), 2)));
+ Table.States (111).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (111), (11, 15, 22), (60, 1), 1);
+ Table.States (111).Kernel := To_Vector ((0 => ((60, 1), 39, 0,
(60, 1), 1)));
+ Table.States (111).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (60, 1), 1)));
+ Table.States (112).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (112), 11, (64, 0), 125);
+ Add_Action (Table.States (112), 15, (63, 0), 126);
+ Add_Action (Table.States (112), 22, (65, 0), 127);
+ Table.States (112).Kernel := To_Vector ((((63, 0), 60, 3,
(32767, 0), 0), ((64, 0), 60, 4, (32767, 0),
+ 0), ((65, 0), 60, 2, (32767, 0), 0)));
+ Table.States (112).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (65, 0), 22, 127)));
+ Table.States (113).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (113), 15, (74, 0), 128);
+ Table.States (113).Kernel := To_Vector ((0 => ((74, 0), 39, 4,
(32767, 0), 0)));
+ Table.States (113).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (74, 0), 15, 128)));
+ Table.States (114).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (114), 39, (69, 1), 129);
+ Table.States (114).Kernel := To_Vector ((0 => ((69, 1), 30, 3,
(32767, 0), 0)));
+ Table.States (114).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (69, 1), 39, 129)));
+ Table.States (115).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (115), 12, (59, 0), 130);
+ Add_Action (Table.States (115), 13, (59, 1), 131);
+ Add_Action (Table.States (115), 16, (43, 0), 132);
+ Add_Action (Table.States (115), 21, (45, 0), 9);
+ Add_Action (Table.States (115), 29, Reduce, (60, 0), 0);
+ Add_Action (Table.States (115), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (115), 35, Reduce, (60, 0), 0);
+ Add_Action (Table.States (115), 36, Reduce, (60, 0), 0);
+ Add_Action (Table.States (115), 39, (60, 1), 133);
+ Add_Action (Table.States (115), 40, (71, 0), 134);
+ Table.States (115).Goto_List.Set_Capacity (9);
+ Add_Goto (Table.States (115), 43, 135);
+ Add_Goto (Table.States (115), 45, 136);
+ Add_Goto (Table.States (115), 46, 137);
+ Add_Goto (Table.States (115), 58, 138);
+ Add_Goto (Table.States (115), 59, 139);
+ Add_Goto (Table.States (115), 60, 140);
+ Add_Goto (Table.States (115), 61, 141);
+ Add_Goto (Table.States (115), 71, 142);
+ Add_Goto (Table.States (115), 73, 143);
+ Table.States (115).Kernel := To_Vector ((0 => ((69, 0), 31, 1,
(32767, 0), 0)));
+ Table.States (115).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (58, 0), 0)));
+ Table.States (116).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (116), (8, 10, 14, 18, 20, 25, 39), (54,
1), 2);
+ Table.States (116).Kernel := To_Vector ((0 => ((54, 1), 53, 0,
(54, 1), 2)));
+ Table.States (116).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (54, 1), 2)));
+ Table.States (117).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (117), 36, Reduce, (60, 0), 0);
+ Add_Action (Table.States (117), 39, (60, 1), 144);
+ Table.States (117).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (117), 60, 145);
+ Table.States (117).Kernel := To_Vector ((0 => ((70, 0), 10, 1,
(32767, 0), 0)));
+ Table.States (117).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (60, 0), 0)));
+ Table.States (118).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (118), (23, 29, 32), (46, 1), 6);
+ Table.States (118).Kernel := To_Vector ((0 => ((46, 1), 23, 0,
(46, 1), 6)));
+ Table.States (118).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (46, 1), 6)));
+ Table.States (119).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (119), 10, (67, 0), 146);
+ Table.States (119).Kernel := To_Vector ((0 => ((67, 0), 55, 2,
(32767, 0), 0)));
+ Table.States (119).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (67, 0), 10, 146)));
+ Table.States (120).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (120), 10, Reduce, (49, 0), 0);
+ Add_Action (Table.States (120), 27, (48, 0), 147);
+ Add_Conflict (Table.States (120), 27, (49, 0), 0);
+ Table.States (120).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (120), 48, 148);
+ Add_Goto (Table.States (120), 49, 149);
+ Table.States (120).Kernel := To_Vector ((0 => ((47, 0), 15, 3,
(32767, 0), 0)));
+ Table.States (120).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (49, 0), 0)));
+ Table.States (121).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (121), 39, (61, 1), 150);
+ Table.States (121).Kernel := To_Vector ((0 => ((61, 1), 33, 1,
(32767, 0), 0)));
+ Table.States (121).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (61, 1), 39, 150)));
+ Table.States (122).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (122), 40, (44, 3), 151);
+ Table.States (122).Kernel := To_Vector ((0 => ((44, 3), 16, 4,
(32767, 0), 0)));
+ Table.States (122).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (44, 3), 40, 151)));
+ Table.States (123).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (123), 19, (56, 2), 152);
+ Add_Action (Table.States (123), 23, Reduce, (56, 0), 0);
+ Add_Action (Table.States (123), 40, (56, 1), 153);
+ Table.States (123).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (123), 56, 154);
+ Table.States (123).Kernel := To_Vector ((((44, 1), 16, 3,
(32767, 0), 0), ((44, 2), 16, 5, (32767, 0),
+ 0)));
+ Table.States (123).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (56, 0), 0)));
+ Table.States (124).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (124), 12, (59, 0), 130);
+ Add_Action (Table.States (124), 13, (59, 1), 131);
+ Add_Action (Table.States (124), 16, (43, 0), 132);
+ Add_Action (Table.States (124), 21, (45, 0), 9);
+ Add_Action (Table.States (124), 29, Reduce, (60, 0), 0);
+ Add_Action (Table.States (124), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (124), 35, Reduce, (60, 0), 0);
+ Add_Action (Table.States (124), 36, Reduce, (60, 0), 0);
+ Add_Action (Table.States (124), 39, (60, 1), 133);
+ Add_Action (Table.States (124), 40, (71, 0), 134);
+ Table.States (124).Goto_List.Set_Capacity (9);
+ Add_Goto (Table.States (124), 43, 135);
+ Add_Goto (Table.States (124), 45, 136);
+ Add_Goto (Table.States (124), 46, 137);
+ Add_Goto (Table.States (124), 58, 155);
+ Add_Goto (Table.States (124), 59, 139);
+ Add_Goto (Table.States (124), 60, 140);
+ Add_Goto (Table.States (124), 61, 141);
+ Add_Goto (Table.States (124), 71, 142);
+ Add_Goto (Table.States (124), 73, 143);
+ Table.States (124).Kernel := To_Vector ((0 => ((44, 0), 26, 1,
(32767, 0), 0)));
+ Table.States (124).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (58, 0), 0)));
+ Table.States (125).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (125), 15, Reduce, (60, 0), 0);
+ Add_Action (Table.States (125), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (125), 39, (60, 1), 105);
+ Table.States (125).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (125), 60, 106);
+ Add_Goto (Table.States (125), 61, 156);
+ Table.States (125).Kernel := To_Vector ((0 => ((64, 0), 11, 3,
(32767, 0), 0)));
+ Table.States (125).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (61, 0), 0)));
+ Table.States (126).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (126), 8, (47, 0), 85);
+ Add_Action (Table.States (126), 10, Reduce, (55, 0), 0);
+ Add_Action (Table.States (126), 14, (44, 0), 86);
+ Add_Action (Table.States (126), 18, (69, 4), 87);
+ Add_Action (Table.States (126), 20, (63, 0), 88);
+ Add_Action (Table.States (126), 25, (74, 0), 89);
+ Add_Action (Table.States (126), 39, (69, 0), 90);
+ Table.States (126).Goto_List.Set_Capacity (11);
+ Add_Goto (Table.States (126), 44, 91);
+ Add_Goto (Table.States (126), 47, 92);
+ Add_Goto (Table.States (126), 53, 93);
+ Add_Goto (Table.States (126), 54, 94);
+ Add_Goto (Table.States (126), 55, 157);
+ Add_Goto (Table.States (126), 62, 96);
+ Add_Goto (Table.States (126), 63, 97);
+ Add_Goto (Table.States (126), 64, 98);
+ Add_Goto (Table.States (126), 65, 99);
+ Add_Goto (Table.States (126), 69, 100);
+ Add_Goto (Table.States (126), 74, 101);
+ Table.States (126).Kernel := To_Vector ((0 => ((63, 0), 15, 2,
(32767, 0), 0)));
+ Table.States (126).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (55, 0), 0)));
+ Table.States (127).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (127), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (127), 36, Reduce, (60, 0), 0);
+ Add_Action (Table.States (127), 39, (60, 1), 158);
+ Table.States (127).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (127), 60, 159);
+ Add_Goto (Table.States (127), 61, 160);
+ Table.States (127).Kernel := To_Vector ((0 => ((65, 0), 22, 1,
(32767, 0), 0)));
+ Table.States (127).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (61, 0), 0)));
+ Table.States (128).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (128), 16, (43, 0), 161);
+ Table.States (128).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (128), 43, 162);
+ Table.States (128).Kernel := To_Vector ((0 => ((74, 0), 15, 3,
(32767, 0), 0)));
+ Table.States (128).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (43, 0), 16, 161)));
+ Table.States (129).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (129), 31, (69, 1), 163);
+ Table.States (129).Kernel := To_Vector ((0 => ((69, 1), 39, 2,
(32767, 0), 0)));
+ Table.States (129).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (69, 1), 31, 163)));
+ Table.States (130).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (130), 16, (43, 0), 164);
+ Table.States (130).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (130), 43, 165);
+ Table.States (130).Kernel := To_Vector ((0 => ((59, 0), 12, 2,
(32767, 0), 0)));
+ Table.States (130).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (43, 0), 16, 164)));
+ Table.States (131).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (131), 16, (43, 0), 164);
+ Table.States (131).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (131), 43, 166);
+ Table.States (131).Kernel := To_Vector ((0 => ((59, 1), 13, 2,
(32767, 0), 0)));
+ Table.States (131).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (43, 0), 16, 164)));
+ Table.States (132).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (132), 12, (59, 0), 32);
+ Add_Action (Table.States (132), 13, (59, 1), 33);
+ Add_Action (Table.States (132), 16, (43, 0), 34);
+ Add_Action (Table.States (132), 21, (45, 0), 9);
+ Add_Action (Table.States (132), 23, (73, 1), 167);
+ Add_Conflict (Table.States (132), 23, (60, 0), 0);
+ Add_Action (Table.States (132), 29, Reduce, (60, 0), 0);
+ Add_Action (Table.States (132), 32, Reduce, (60, 0), 0);
+ Add_Action (Table.States (132), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (132), 35, Reduce, (60, 0), 0);
+ Add_Action (Table.States (132), 39, (60, 1), 36);
+ Add_Action (Table.States (132), 40, (71, 0), 37);
+ Table.States (132).Goto_List.Set_Capacity (10);
+ Add_Goto (Table.States (132), 43, 38);
+ Add_Goto (Table.States (132), 45, 39);
+ Add_Goto (Table.States (132), 46, 40);
+ Add_Goto (Table.States (132), 58, 41);
+ Add_Goto (Table.States (132), 59, 42);
+ Add_Goto (Table.States (132), 60, 43);
+ Add_Goto (Table.States (132), 61, 44);
+ Add_Goto (Table.States (132), 71, 45);
+ Add_Goto (Table.States (132), 72, 168);
+ Add_Goto (Table.States (132), 73, 47);
+ Table.States (132).Kernel := To_Vector ((((43, 0), 16, 1,
(32767, 0), 0), ((73, 1), 16, 1, (32767, 0),
+ 0)));
+ Table.States (132).Minimal_Complete_Actions := To_Vector
(((Reduce, (72, 0), 0), (Shift, (73, 1), 23,
+ 167)));
+ Table.States (133).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (133), (29, 33, 35, 36), (60, 1), 1);
+ Table.States (133).Kernel := To_Vector ((0 => ((60, 1), 39, 0,
(60, 1), 1)));
+ Table.States (133).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (60, 1), 1)));
+ Table.States (134).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (134), (29, 36), (71, 0), 1);
+ Table.States (134).Kernel := To_Vector ((0 => ((71, 0), 40, 0,
(71, 0), 1)));
+ Table.States (134).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (71, 0), 1)));
+ Table.States (135).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (135), (29, 36), (73, 2), 1);
+ Table.States (135).Kernel := To_Vector ((0 => ((73, 2), 43, 0,
(73, 2), 1)));
+ Table.States (135).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (73, 2), 1)));
+ Table.States (136).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (136), 35, (46, 0), 169);
+ Table.States (136).Kernel := To_Vector ((((46, 0), 45, 2,
(32767, 0), 0), ((46, 1), 45, 5, (32767, 0),
+ 0)));
+ Table.States (136).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (46, 0), 35, 169)));
+ Table.States (137).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (137), (29, 36), (71, 3), 1);
+ Table.States (137).Kernel := To_Vector ((0 => ((71, 3), 46, 0,
(71, 3), 1)));
+ Table.States (137).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (71, 3), 1)));
+ Table.States (138).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (138), 29, (58, 1), 170);
+ Add_Action (Table.States (138), 36, (69, 0), 171);
+ Table.States (138).Kernel := To_Vector ((((58, 1), 58, 1,
(32767, 0), 0), ((69, 0), 58, 1, (32767, 0),
+ 0)));
+ Table.States (138).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (69, 0), 36, 171)));
+ Table.States (139).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (139), (29, 36), (71, 2), 1);
+ Table.States (139).Kernel := To_Vector ((0 => ((71, 2), 59, 0,
(71, 2), 1)));
+ Table.States (139).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (71, 2), 1)));
+ Table.States (140).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (140), (29, 33, 35, 36), (61, 0), 1);
+ Table.States (140).Kernel := To_Vector ((0 => ((61, 0), 60, 0,
(61, 0), 1)));
+ Table.States (140).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (61, 0), 1)));
+ Table.States (141).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (141), 29, Reduce, (71, 1), 1);
+ Add_Action (Table.States (141), 33, (61, 1), 172);
+ Add_Action (Table.States (141), 35, Reduce, (45, 1), 1);
+ Add_Action (Table.States (141), 36, Reduce, (71, 1), 1);
+ Table.States (141).Kernel := To_Vector ((((45, 1), 61, 0, (45,
1), 1), ((61, 1), 61, 2, (32767, 0),
+ 0), ((71, 1), 61, 0, (71, 1), 1)));
+ Table.States (141).Minimal_Complete_Actions := To_Vector
(((Reduce, (45, 1), 1), (Reduce, (71, 1), 1)));
+ Table.States (142).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (142), (29, 36), (73, 0), 1);
+ Table.States (142).Kernel := To_Vector ((0 => ((73, 0), 71, 0,
(73, 0), 1)));
+ Table.States (142).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (73, 0), 1)));
+ Table.States (143).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (143), (29, 36), (58, 0), 1);
+ Table.States (143).Kernel := To_Vector ((0 => ((58, 0), 73, 0,
(58, 0), 1)));
+ Table.States (143).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (58, 0), 1)));
+ Table.States (144).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (144), (1 => 36), (60, 1), 1);
+ Table.States (144).Kernel := To_Vector ((0 => ((60, 1), 39, 0,
(60, 1), 1)));
+ Table.States (144).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (60, 1), 1)));
+ Table.States (145).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (145), 36, (70, 0), 173);
+ Table.States (145).Kernel := To_Vector ((0 => ((70, 0), 60, 1,
(32767, 0), 0)));
+ Table.States (145).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (70, 0), 36, 173)));
+ Table.States (146).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (146), 36, Reduce, (60, 0), 0);
+ Add_Action (Table.States (146), 39, (60, 1), 144);
+ Table.States (146).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (146), 60, 174);
+ Table.States (146).Kernel := To_Vector ((0 => ((67, 0), 10, 1,
(32767, 0), 0)));
+ Table.States (146).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (60, 0), 0)));
+ Table.States (147).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (147), 19, (56, 2), 175);
+ Add_Action (Table.States (147), 34, Reduce, (56, 0), 0);
+ Add_Action (Table.States (147), 37, Reduce, (56, 0), 0);
+ Add_Action (Table.States (147), 40, (56, 1), 176);
+ Table.States (147).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (147), 56, 177);
+ Add_Goto (Table.States (147), 57, 178);
+ Table.States (147).Kernel := To_Vector ((0 => ((48, 0), 27, 1,
(32767, 0), 0)));
+ Table.States (147).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (57, 0), 0)));
+ Table.States (148).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (148), (10, 27), (49, 1), 1);
+ Table.States (148).Kernel := To_Vector ((0 => ((49, 1), 48, 0,
(49, 1), 1)));
+ Table.States (148).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (49, 1), 1)));
+ Table.States (149).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (149), 10, (47, 0), 179);
+ Add_Action (Table.States (149), 27, (48, 0), 147);
+ Table.States (149).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (149), 48, 180);
+ Table.States (149).Kernel := To_Vector ((((47, 0), 49, 3,
(32767, 0), 0), ((49, 2), 49, 2, (32767, 0),
+ 0)));
+ Table.States (149).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (47, 0), 10, 179)));
+ Table.States (150).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (150), (15, 33), (61, 1), 3);
+ Table.States (150).Kernel := To_Vector ((0 => ((61, 1), 39, 0,
(61, 1), 3)));
+ Table.States (150).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (61, 1), 3)));
+ Table.States (151).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (151), 23, (44, 3), 181);
+ Table.States (151).Kernel := To_Vector ((0 => ((44, 3), 40, 3,
(32767, 0), 0)));
+ Table.States (151).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (44, 3), 23, 181)));
+ Table.States (152).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (152), (1 => 23), (56, 2), 1);
+ Table.States (152).Kernel := To_Vector ((0 => ((56, 2), 19, 0,
(56, 2), 1)));
+ Table.States (152).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (56, 2), 1)));
+ Table.States (153).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (153), (1 => 23), (56, 1), 1);
+ Table.States (153).Kernel := To_Vector ((0 => ((56, 1), 40, 0,
(56, 1), 1)));
+ Table.States (153).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (56, 1), 1)));
+ Table.States (154).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (154), 23, (44, 1), 182);
+ Table.States (154).Kernel := To_Vector ((((44, 1), 56, 3,
(32767, 0), 0), ((44, 2), 56, 5, (32767, 0),
+ 0)));
+ Table.States (154).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (44, 1), 23, 182)));
+ Table.States (155).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (155), 29, (58, 1), 170);
+ Add_Action (Table.States (155), 36, (44, 0), 183);
+ Table.States (155).Kernel := To_Vector ((((44, 0), 58, 1,
(32767, 0), 0), ((58, 1), 58, 1, (32767, 0),
+ 0)));
+ Table.States (155).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (44, 0), 36, 183)));
+ Table.States (156).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (156), 15, (64, 0), 184);
+ Add_Action (Table.States (156), 33, (61, 1), 121);
+ Table.States (156).Kernel := To_Vector ((((61, 1), 61, 2,
(32767, 0), 0), ((64, 0), 61, 3, (32767, 0),
+ 0)));
+ Table.States (156).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (64, 0), 15, 184)));
+ Table.States (157).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (157), 10, (63, 0), 185);
+ Table.States (157).Kernel := To_Vector ((0 => ((63, 0), 55, 2,
(32767, 0), 0)));
+ Table.States (157).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (63, 0), 10, 185)));
+ Table.States (158).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (158), (33, 36), (60, 1), 1);
+ Table.States (158).Kernel := To_Vector ((0 => ((60, 1), 39, 0,
(60, 1), 1)));
+ Table.States (158).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (60, 1), 1)));
+ end Subr_3;
+ procedure Subr_4
+ is begin
+ Table.States (159).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (159), (33, 36), (61, 0), 1);
+ Table.States (159).Kernel := To_Vector ((0 => ((61, 0), 60, 0,
(61, 0), 1)));
+ Table.States (159).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (61, 0), 1)));
+ Table.States (160).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (160), 33, (61, 1), 186);
+ Add_Action (Table.States (160), 36, (65, 0), 187);
+ Table.States (160).Kernel := To_Vector ((((61, 1), 61, 2,
(32767, 0), 0), ((65, 0), 61, 1, (32767, 0),
+ 0)));
+ Table.States (160).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (65, 0), 36, 187)));
+ Table.States (161).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (161), 12, (59, 0), 32);
+ Add_Action (Table.States (161), 13, (59, 1), 33);
+ Add_Action (Table.States (161), 16, (43, 0), 34);
+ Add_Action (Table.States (161), 21, (45, 0), 9);
+ Add_Action (Table.States (161), 23, Reduce, (60, 0), 0);
+ Add_Action (Table.States (161), 29, Reduce, (60, 0), 0);
+ Add_Action (Table.States (161), 32, Reduce, (60, 0), 0);
+ Add_Action (Table.States (161), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (161), 35, Reduce, (60, 0), 0);
+ Add_Action (Table.States (161), 39, (60, 1), 36);
+ Add_Action (Table.States (161), 40, (71, 0), 37);
+ Table.States (161).Goto_List.Set_Capacity (10);
+ Add_Goto (Table.States (161), 43, 38);
+ Add_Goto (Table.States (161), 45, 39);
+ Add_Goto (Table.States (161), 46, 40);
+ Add_Goto (Table.States (161), 58, 41);
+ Add_Goto (Table.States (161), 59, 42);
+ Add_Goto (Table.States (161), 60, 43);
+ Add_Goto (Table.States (161), 61, 44);
+ Add_Goto (Table.States (161), 71, 45);
+ Add_Goto (Table.States (161), 72, 188);
+ Add_Goto (Table.States (161), 73, 47);
+ Table.States (161).Kernel := To_Vector ((0 => ((43, 0), 16, 1,
(32767, 0), 0)));
+ Table.States (161).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (72, 0), 0)));
+ Table.States (162).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (162), 36, (74, 0), 189);
+ Table.States (162).Kernel := To_Vector ((0 => ((74, 0), 43, 1,
(32767, 0), 0)));
+ Table.States (162).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (74, 0), 36, 189)));
+ Table.States (163).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (163), 12, (59, 0), 130);
+ Add_Action (Table.States (163), 13, (59, 1), 131);
+ Add_Action (Table.States (163), 16, (43, 0), 132);
+ Add_Action (Table.States (163), 21, (45, 0), 9);
+ Add_Action (Table.States (163), 29, Reduce, (60, 0), 0);
+ Add_Action (Table.States (163), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (163), 35, Reduce, (60, 0), 0);
+ Add_Action (Table.States (163), 36, Reduce, (60, 0), 0);
+ Add_Action (Table.States (163), 39, (60, 1), 133);
+ Add_Action (Table.States (163), 40, (71, 0), 134);
+ Table.States (163).Goto_List.Set_Capacity (9);
+ Add_Goto (Table.States (163), 43, 135);
+ Add_Goto (Table.States (163), 45, 136);
+ Add_Goto (Table.States (163), 46, 137);
+ Add_Goto (Table.States (163), 58, 190);
+ Add_Goto (Table.States (163), 59, 139);
+ Add_Goto (Table.States (163), 60, 140);
+ Add_Goto (Table.States (163), 61, 141);
+ Add_Goto (Table.States (163), 71, 142);
+ Add_Goto (Table.States (163), 73, 143);
+ Table.States (163).Kernel := To_Vector ((0 => ((69, 1), 31, 1,
(32767, 0), 0)));
+ Table.States (163).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (58, 0), 0)));
+ Table.States (164).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (164), 12, (59, 0), 32);
+ Add_Action (Table.States (164), 13, (59, 1), 33);
+ Add_Action (Table.States (164), 16, (43, 0), 34);
+ Add_Action (Table.States (164), 21, (45, 0), 9);
+ Add_Action (Table.States (164), 23, Reduce, (60, 0), 0);
+ Add_Action (Table.States (164), 29, Reduce, (60, 0), 0);
+ Add_Action (Table.States (164), 32, Reduce, (60, 0), 0);
+ Add_Action (Table.States (164), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (164), 35, Reduce, (60, 0), 0);
+ Add_Action (Table.States (164), 39, (60, 1), 36);
+ Add_Action (Table.States (164), 40, (71, 0), 37);
+ Table.States (164).Goto_List.Set_Capacity (10);
+ Add_Goto (Table.States (164), 43, 38);
+ Add_Goto (Table.States (164), 45, 39);
+ Add_Goto (Table.States (164), 46, 40);
+ Add_Goto (Table.States (164), 58, 41);
+ Add_Goto (Table.States (164), 59, 42);
+ Add_Goto (Table.States (164), 60, 43);
+ Add_Goto (Table.States (164), 61, 44);
+ Add_Goto (Table.States (164), 71, 45);
+ Add_Goto (Table.States (164), 72, 168);
+ Add_Goto (Table.States (164), 73, 47);
+ Table.States (164).Kernel := To_Vector ((0 => ((43, 0), 16, 1,
(32767, 0), 0)));
+ Table.States (164).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (72, 0), 0)));
+ Table.States (165).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (165), (29, 36), (59, 0), 2);
+ Table.States (165).Kernel := To_Vector ((0 => ((59, 0), 43, 0,
(59, 0), 2)));
+ Table.States (165).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (59, 0), 2)));
+ Table.States (166).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (166), (29, 36), (59, 1), 2);
+ Table.States (166).Kernel := To_Vector ((0 => ((59, 1), 43, 0,
(59, 1), 2)));
+ Table.States (166).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (59, 1), 2)));
+ Table.States (167).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (167), (29, 36), (73, 1), 2);
+ Table.States (167).Kernel := To_Vector ((0 => ((73, 1), 23, 0,
(73, 1), 2)));
+ Table.States (167).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (73, 1), 2)));
+ Table.States (168).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (168), 23, (43, 0), 191);
+ Add_Action (Table.States (168), 32, (72, 1), 67);
+ Table.States (168).Kernel := To_Vector ((((43, 0), 72, 1,
(32767, 0), 0), ((72, 1), 72, 1, (32767, 0),
+ 0)));
+ Table.States (168).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (43, 0), 23, 191)));
+ Table.States (169).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (169), 39, (46, 0), 192);
+ Table.States (169).Kernel := To_Vector ((((46, 0), 35, 1,
(32767, 0), 0), ((46, 1), 35, 4, (32767, 0),
+ 0)));
+ Table.States (169).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (46, 0), 39, 192)));
+ Table.States (170).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (170), 12, (59, 0), 130);
+ Add_Action (Table.States (170), 13, (59, 1), 131);
+ Add_Action (Table.States (170), 16, (43, 0), 132);
+ Add_Action (Table.States (170), 21, (45, 0), 9);
+ Add_Action (Table.States (170), 29, Reduce, (60, 0), 0);
+ Add_Action (Table.States (170), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (170), 35, Reduce, (60, 0), 0);
+ Add_Action (Table.States (170), 36, Reduce, (60, 0), 0);
+ Add_Action (Table.States (170), 39, (60, 1), 133);
+ Add_Action (Table.States (170), 40, (71, 0), 134);
+ Table.States (170).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (170), 43, 135);
+ Add_Goto (Table.States (170), 45, 136);
+ Add_Goto (Table.States (170), 46, 137);
+ Add_Goto (Table.States (170), 59, 139);
+ Add_Goto (Table.States (170), 60, 140);
+ Add_Goto (Table.States (170), 61, 141);
+ Add_Goto (Table.States (170), 71, 142);
+ Add_Goto (Table.States (170), 73, 193);
+ Table.States (170).Kernel := To_Vector ((0 => ((58, 1), 29, 0,
(73, 0), 0)));
+ Table.States (170).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (73, 0), 0)));
+ Table.States (171).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (171), (8, 10, 14, 18, 20, 25, 39), (69,
0), 4);
+ Table.States (171).Kernel := To_Vector ((0 => ((69, 0), 36, 0,
(69, 0), 4)));
+ Table.States (171).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (69, 0), 4)));
+ Table.States (172).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (172), 39, (61, 1), 194);
+ Table.States (172).Kernel := To_Vector ((0 => ((61, 1), 33, 1,
(32767, 0), 0)));
+ Table.States (172).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (61, 1), 39, 194)));
+ Table.States (173).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (173), (1 => 41), (70, 0), 7);
+ Table.States (173).Kernel := To_Vector ((0 => ((70, 0), 36, 0,
(70, 0), 7)));
+ Table.States (173).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (70, 0), 7)));
+ Table.States (174).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (174), 36, (67, 0), 195);
+ Table.States (174).Kernel := To_Vector ((0 => ((67, 0), 60, 1,
(32767, 0), 0)));
+ Table.States (174).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (67, 0), 36, 195)));
+ Table.States (175).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (175), (34, 37), (56, 2), 1);
+ Table.States (175).Kernel := To_Vector ((0 => ((56, 2), 19, 0,
(56, 2), 1)));
+ Table.States (175).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (56, 2), 1)));
+ Table.States (176).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (176), (34, 37), (56, 1), 1);
+ Table.States (176).Kernel := To_Vector ((0 => ((56, 1), 40, 0,
(56, 1), 1)));
+ Table.States (176).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (56, 1), 1)));
+ Table.States (177).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (177), (34, 37), (57, 0), 1);
+ Table.States (177).Kernel := To_Vector ((0 => ((57, 0), 56, 0,
(57, 0), 1)));
+ Table.States (177).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (57, 0), 1)));
+ Table.States (178).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (178), 34, (48, 0), 196);
+ Add_Action (Table.States (178), 37, (57, 1), 197);
+ Table.States (178).Kernel := To_Vector ((((48, 0), 57, 1,
(32767, 0), 0), ((57, 1), 57, 1, (32767, 0),
+ 0)));
+ Table.States (178).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (48, 0), 34, 196)));
+ Table.States (179).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (179), 8, (47, 0), 198);
+ Table.States (179).Kernel := To_Vector ((0 => ((47, 0), 10, 2,
(32767, 0), 0)));
+ Table.States (179).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (47, 0), 8, 198)));
+ Table.States (180).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (180), (10, 27), (49, 2), 2);
+ Table.States (180).Kernel := To_Vector ((0 => ((49, 2), 48, 0,
(49, 2), 2)));
+ Table.States (180).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (49, 2), 2)));
+ Table.States (181).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (181), 26, (44, 3), 199);
+ Table.States (181).Kernel := To_Vector ((0 => ((44, 3), 23, 2,
(32767, 0), 0)));
+ Table.States (181).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (44, 3), 26, 199)));
+ Table.States (182).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (182), 26, (44, 1), 200);
+ Table.States (182).Kernel := To_Vector ((((44, 1), 23, 2,
(32767, 0), 0), ((44, 2), 23, 4, (32767, 0),
+ 0)));
+ Table.States (182).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (44, 1), 26, 200)));
+ Table.States (183).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (183), (8, 10, 14, 18, 20, 25, 39), (44,
0), 5);
+ Table.States (183).Kernel := To_Vector ((0 => ((44, 0), 36, 0,
(44, 0), 5)));
+ Table.States (183).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (44, 0), 5)));
+ Table.States (184).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (184), 8, (47, 0), 85);
+ Add_Action (Table.States (184), 10, Reduce, (55, 0), 0);
+ Add_Action (Table.States (184), 14, (44, 0), 86);
+ Add_Action (Table.States (184), 18, (69, 4), 87);
+ Add_Action (Table.States (184), 20, (63, 0), 88);
+ Add_Action (Table.States (184), 25, (74, 0), 89);
+ Add_Action (Table.States (184), 39, (69, 0), 90);
+ Table.States (184).Goto_List.Set_Capacity (11);
+ Add_Goto (Table.States (184), 44, 91);
+ Add_Goto (Table.States (184), 47, 92);
+ Add_Goto (Table.States (184), 53, 93);
+ Add_Goto (Table.States (184), 54, 94);
+ Add_Goto (Table.States (184), 55, 201);
+ Add_Goto (Table.States (184), 62, 96);
+ Add_Goto (Table.States (184), 63, 97);
+ Add_Goto (Table.States (184), 64, 98);
+ Add_Goto (Table.States (184), 65, 99);
+ Add_Goto (Table.States (184), 69, 100);
+ Add_Goto (Table.States (184), 74, 101);
+ Table.States (184).Kernel := To_Vector ((0 => ((64, 0), 15, 2,
(32767, 0), 0)));
+ Table.States (184).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (55, 0), 0)));
+ Table.States (185).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (185), 36, Reduce, (60, 0), 0);
+ Add_Action (Table.States (185), 39, (60, 1), 144);
+ Table.States (185).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (185), 60, 202);
+ Table.States (185).Kernel := To_Vector ((0 => ((63, 0), 10, 1,
(32767, 0), 0)));
+ Table.States (185).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (60, 0), 0)));
+ Table.States (186).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (186), 39, (61, 1), 203);
+ Table.States (186).Kernel := To_Vector ((0 => ((61, 1), 33, 1,
(32767, 0), 0)));
+ Table.States (186).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (61, 1), 39, 203)));
+ Table.States (187).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (187), (8, 10, 14, 18, 20, 25, 39), (65,
0), 5);
+ Table.States (187).Kernel := To_Vector ((0 => ((65, 0), 36, 0,
(65, 0), 5)));
+ Table.States (187).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (65, 0), 5)));
+ Table.States (188).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (188), 23, (43, 0), 204);
+ Add_Action (Table.States (188), 32, (72, 1), 67);
+ Table.States (188).Kernel := To_Vector ((((43, 0), 72, 1,
(32767, 0), 0), ((72, 1), 72, 1, (32767, 0),
+ 0)));
+ Table.States (188).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (43, 0), 23, 204)));
+ Table.States (189).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (189), (8, 10, 14, 18, 20, 25, 39), (74,
0), 5);
+ Table.States (189).Kernel := To_Vector ((0 => ((74, 0), 36, 0,
(74, 0), 5)));
+ Table.States (189).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (74, 0), 5)));
+ Table.States (190).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (190), 29, (58, 1), 170);
+ Add_Action (Table.States (190), 36, (69, 1), 205);
+ Table.States (190).Kernel := To_Vector ((((58, 1), 58, 1,
(32767, 0), 0), ((69, 1), 58, 1, (32767, 0),
+ 0)));
+ Table.States (190).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (69, 1), 36, 205)));
+ Table.States (191).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (191), (29, 36), (43, 0), 3);
+ Table.States (191).Kernel := To_Vector ((0 => ((43, 0), 23, 0,
(43, 0), 3)));
+ Table.States (191).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (43, 0), 3)));
+ Table.States (192).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (192), 16, (46, 1), 206);
+ Add_Action (Table.States (192), 29, Reduce, (46, 0), 3);
+ Add_Action (Table.States (192), 36, Reduce, (46, 0), 3);
+ Table.States (192).Kernel := To_Vector ((((46, 0), 39, 0, (46,
0), 3), ((46, 1), 39, 3, (32767, 0),
+ 0)));
+ Table.States (192).Minimal_Complete_Actions := To_Vector
(((Reduce, (46, 0), 3), (Shift, (46, 1), 16,
+ 206)));
+ Table.States (193).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (193), (29, 36), (58, 1), 3);
+ Table.States (193).Kernel := To_Vector ((0 => ((58, 1), 73, 0,
(58, 1), 3)));
+ Table.States (193).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (58, 1), 3)));
+ Table.States (194).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (194), (29, 33, 35, 36), (61, 1), 3);
+ Table.States (194).Kernel := To_Vector ((0 => ((61, 1), 39, 0,
(61, 1), 3)));
+ Table.States (194).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (61, 1), 3)));
+ Table.States (195).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (195), (1 => 41), (67, 0), 9);
+ Table.States (195).Kernel := To_Vector ((0 => ((67, 0), 36, 0,
(67, 0), 9)));
+ Table.States (195).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (67, 0), 9)));
+ Table.States (196).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (196), 8, (47, 0), 207);
+ Add_Action (Table.States (196), 10, Reduce, (55, 0), 0);
+ Add_Action (Table.States (196), 14, (44, 0), 208);
+ Add_Action (Table.States (196), 18, (69, 4), 209);
+ Add_Action (Table.States (196), 20, (63, 0), 210);
+ Add_Action (Table.States (196), 25, (74, 0), 211);
+ Add_Action (Table.States (196), 27, Reduce, (55, 0), 0);
+ Add_Action (Table.States (196), 39, (69, 0), 212);
+ Table.States (196).Goto_List.Set_Capacity (11);
+ Add_Goto (Table.States (196), 44, 213);
+ Add_Goto (Table.States (196), 47, 214);
+ Add_Goto (Table.States (196), 53, 215);
+ Add_Goto (Table.States (196), 54, 216);
+ Add_Goto (Table.States (196), 55, 217);
+ Add_Goto (Table.States (196), 62, 218);
+ Add_Goto (Table.States (196), 63, 219);
+ Add_Goto (Table.States (196), 64, 220);
+ Add_Goto (Table.States (196), 65, 221);
+ Add_Goto (Table.States (196), 69, 222);
+ Add_Goto (Table.States (196), 74, 223);
+ Table.States (196).Kernel := To_Vector ((0 => ((48, 0), 34, 0,
(55, 0), 0)));
+ Table.States (196).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (55, 0), 0)));
+ Table.States (197).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (197), 19, (56, 2), 175);
+ Add_Action (Table.States (197), 34, Reduce, (56, 0), 0);
+ Add_Action (Table.States (197), 37, Reduce, (56, 0), 0);
+ Add_Action (Table.States (197), 40, (56, 1), 176);
+ Table.States (197).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (197), 56, 224);
+ Table.States (197).Kernel := To_Vector ((0 => ((57, 1), 37, 0,
(56, 0), 0)));
+ Table.States (197).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (56, 0), 0)));
+ Table.States (198).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (198), 36, (47, 0), 225);
+ Table.States (198).Kernel := To_Vector ((0 => ((47, 0), 8, 1,
(32767, 0), 0)));
+ Table.States (198).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (47, 0), 36, 225)));
+ Table.States (199).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (199), 12, (59, 0), 130);
+ Add_Action (Table.States (199), 13, (59, 1), 131);
+ Add_Action (Table.States (199), 16, (43, 0), 132);
+ Add_Action (Table.States (199), 21, (45, 0), 9);
+ Add_Action (Table.States (199), 29, Reduce, (60, 0), 0);
+ Add_Action (Table.States (199), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (199), 35, Reduce, (60, 0), 0);
+ Add_Action (Table.States (199), 36, Reduce, (60, 0), 0);
+ Add_Action (Table.States (199), 39, (60, 1), 133);
+ Add_Action (Table.States (199), 40, (71, 0), 134);
+ Table.States (199).Goto_List.Set_Capacity (9);
+ Add_Goto (Table.States (199), 43, 135);
+ Add_Goto (Table.States (199), 45, 136);
+ Add_Goto (Table.States (199), 46, 137);
+ Add_Goto (Table.States (199), 58, 226);
+ Add_Goto (Table.States (199), 59, 139);
+ Add_Goto (Table.States (199), 60, 140);
+ Add_Goto (Table.States (199), 61, 141);
+ Add_Goto (Table.States (199), 71, 142);
+ Add_Goto (Table.States (199), 73, 143);
+ Table.States (199).Kernel := To_Vector ((0 => ((44, 3), 26, 1,
(32767, 0), 0)));
+ Table.States (199).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (58, 0), 0)));
+ Table.States (200).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (200), 6, Reduce, (60, 0), 0);
+ Add_Action (Table.States (200), 12, (59, 0), 227);
+ Add_Action (Table.States (200), 13, (59, 1), 228);
+ Add_Action (Table.States (200), 16, (43, 0), 229);
+ Add_Action (Table.States (200), 21, (45, 0), 9);
+ Add_Action (Table.States (200), 29, Reduce, (60, 0), 0);
+ Add_Action (Table.States (200), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (200), 35, Reduce, (60, 0), 0);
+ Add_Action (Table.States (200), 36, Reduce, (60, 0), 0);
+ Add_Action (Table.States (200), 39, (60, 1), 230);
+ Add_Action (Table.States (200), 40, (71, 0), 231);
+ Table.States (200).Goto_List.Set_Capacity (9);
+ Add_Goto (Table.States (200), 43, 232);
+ Add_Goto (Table.States (200), 45, 233);
+ Add_Goto (Table.States (200), 46, 234);
+ Add_Goto (Table.States (200), 58, 235);
+ Add_Goto (Table.States (200), 59, 236);
+ Add_Goto (Table.States (200), 60, 237);
+ Add_Goto (Table.States (200), 61, 238);
+ Add_Goto (Table.States (200), 71, 239);
+ Add_Goto (Table.States (200), 73, 240);
+ Table.States (200).Kernel := To_Vector ((((44, 1), 26, 1,
(32767, 0), 0), ((44, 2), 26, 3, (32767, 0),
+ 0)));
+ Table.States (200).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (58, 0), 0)));
+ Table.States (201).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (201), 10, (64, 0), 241);
+ Table.States (201).Kernel := To_Vector ((0 => ((64, 0), 55, 2,
(32767, 0), 0)));
+ Table.States (201).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (64, 0), 10, 241)));
+ Table.States (202).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (202), 36, (63, 0), 242);
+ Table.States (202).Kernel := To_Vector ((0 => ((63, 0), 60, 1,
(32767, 0), 0)));
+ Table.States (202).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (63, 0), 36, 242)));
+ Table.States (203).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (203), (33, 36), (61, 1), 3);
+ Table.States (203).Kernel := To_Vector ((0 => ((61, 1), 39, 0,
(61, 1), 3)));
+ Table.States (203).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (61, 1), 3)));
+ Table.States (204).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (204), (1 => 36), (43, 0), 3);
+ Table.States (204).Kernel := To_Vector ((0 => ((43, 0), 23, 0,
(43, 0), 3)));
+ Table.States (204).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (43, 0), 3)));
+ Table.States (205).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (205), (8, 10, 14, 18, 20, 25, 39), (69,
1), 6);
+ Table.States (205).Kernel := To_Vector ((0 => ((69, 1), 36, 0,
(69, 1), 6)));
+ Table.States (205).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (69, 1), 6)));
+ Table.States (206).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (206), 40, (46, 1), 243);
+ Table.States (206).Kernel := To_Vector ((0 => ((46, 1), 16, 2,
(32767, 0), 0)));
+ Table.States (206).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (46, 1), 40, 243)));
+ end Subr_4;
+ procedure Subr_5
+ is begin
+ Table.States (207).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (207), 15, Reduce, (60, 0), 0);
+ Add_Action (Table.States (207), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (207), 39, (60, 1), 105);
+ Table.States (207).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (207), 60, 106);
+ Add_Goto (Table.States (207), 61, 244);
+ Table.States (207).Kernel := To_Vector ((0 => ((47, 0), 8, 4,
(32767, 0), 0)));
+ Table.States (207).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (61, 0), 0)));
+ Table.States (208).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (208), 12, (44, 3), 245);
+ Add_Action (Table.States (208), 39, (44, 0), 246);
+ Table.States (208).Kernel := To_Vector ((((44, 0), 14, 3,
(32767, 0), 0), ((44, 1), 14, 5, (32767, 0),
+ 0), ((44, 2), 14, 7, (32767, 0), 0), ((44, 3), 14, 6,
(32767, 0), 0)));
+ Table.States (208).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (44, 0), 39, 246)));
+ Table.States (209).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (209), 36, (69, 4), 247);
+ Table.States (209).Kernel := To_Vector ((0 => ((69, 4), 18, 1,
(32767, 0), 0)));
+ Table.States (209).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (69, 4), 36, 247)));
+ Table.States (210).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (210), 11, Reduce, (60, 0), 0);
+ Add_Action (Table.States (210), 15, Reduce, (60, 0), 0);
+ Add_Action (Table.States (210), 22, Reduce, (60, 0), 0);
+ Add_Action (Table.States (210), 39, (60, 1), 111);
+ Table.States (210).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (210), 60, 248);
+ Table.States (210).Kernel := To_Vector ((((63, 0), 20, 3,
(32767, 0), 0), ((64, 0), 20, 4, (32767, 0),
+ 0), ((65, 0), 20, 2, (32767, 0), 0)));
+ Table.States (210).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (60, 0), 0)));
+ Table.States (211).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (211), 39, (74, 0), 249);
+ Table.States (211).Kernel := To_Vector ((0 => ((74, 0), 25, 5,
(32767, 0), 0)));
+ Table.States (211).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (74, 0), 39, 249)));
+ Table.States (212).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (212), 30, (69, 1), 250);
+ Add_Action (Table.States (212), 31, (69, 0), 251);
+ Table.States (212).Kernel := To_Vector ((((69, 0), 39, 2,
(32767, 0), 0), ((69, 1), 39, 4, (32767, 0),
+ 0)));
+ Table.States (212).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (69, 0), 31, 251)));
+ Table.States (213).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (213), (8, 10, 14, 18, 20, 25, 27, 39),
(69, 2), 1);
+ Table.States (213).Kernel := To_Vector ((0 => ((69, 2), 44, 0,
(69, 2), 1)));
+ Table.States (213).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (69, 2), 1)));
+ Table.States (214).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (214), (8, 10, 14, 18, 20, 25, 27, 39),
(69, 3), 1);
+ Table.States (214).Kernel := To_Vector ((0 => ((69, 3), 47, 0,
(69, 3), 1)));
+ Table.States (214).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (69, 3), 1)));
+ Table.States (215).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (215), (8, 10, 14, 18, 20, 25, 27, 39),
(54, 0), 1);
+ Table.States (215).Kernel := To_Vector ((0 => ((54, 0), 53, 0,
(54, 0), 1)));
+ Table.States (215).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (54, 0), 1)));
+ Table.States (216).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (216), 8, (47, 0), 207);
+ Add_Action (Table.States (216), 10, Reduce, (55, 1), 1);
+ Add_Action (Table.States (216), 14, (44, 0), 208);
+ Add_Action (Table.States (216), 18, (69, 4), 209);
+ Add_Action (Table.States (216), 20, (63, 0), 210);
+ Add_Action (Table.States (216), 25, (74, 0), 211);
+ Add_Action (Table.States (216), 27, Reduce, (55, 1), 1);
+ Add_Action (Table.States (216), 39, (69, 0), 212);
+ Table.States (216).Goto_List.Set_Capacity (9);
+ Add_Goto (Table.States (216), 44, 213);
+ Add_Goto (Table.States (216), 47, 214);
+ Add_Goto (Table.States (216), 53, 252);
+ Add_Goto (Table.States (216), 62, 218);
+ Add_Goto (Table.States (216), 63, 219);
+ Add_Goto (Table.States (216), 64, 220);
+ Add_Goto (Table.States (216), 65, 221);
+ Add_Goto (Table.States (216), 69, 222);
+ Add_Goto (Table.States (216), 74, 223);
+ Table.States (216).Kernel := To_Vector ((((54, 1), 54, 2,
(32767, 0), 0), ((55, 1), 54, 0, (55, 1),
+ 1)));
+ Table.States (216).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (55, 1), 1)));
+ Table.States (217).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (217), (10, 27), (48, 0), 4);
+ Table.States (217).Kernel := To_Vector ((0 => ((48, 0), 55, 0,
(48, 0), 4)));
+ Table.States (217).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (48, 0), 4)));
+ Table.States (218).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (218), (8, 10, 14, 18, 20, 25, 27, 39),
(53, 2), 1);
+ Table.States (218).Kernel := To_Vector ((0 => ((53, 2), 62, 0,
(53, 2), 1)));
+ Table.States (218).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (53, 2), 1)));
+ Table.States (219).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (219), (8, 10, 14, 18, 20, 25, 27, 39),
(62, 0), 1);
+ Table.States (219).Kernel := To_Vector ((0 => ((62, 0), 63, 0,
(62, 0), 1)));
+ Table.States (219).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (62, 0), 1)));
+ Table.States (220).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (220), (8, 10, 14, 18, 20, 25, 27, 39),
(62, 1), 1);
+ Table.States (220).Kernel := To_Vector ((0 => ((62, 1), 64, 0,
(62, 1), 1)));
+ Table.States (220).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (62, 1), 1)));
+ Table.States (221).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (221), (8, 10, 14, 18, 20, 25, 27, 39),
(62, 2), 1);
+ Table.States (221).Kernel := To_Vector ((0 => ((62, 2), 65, 0,
(62, 2), 1)));
+ Table.States (221).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (62, 2), 1)));
+ Table.States (222).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (222), (8, 10, 14, 18, 20, 25, 27, 39),
(53, 0), 1);
+ Table.States (222).Kernel := To_Vector ((0 => ((53, 0), 69, 0,
(53, 0), 1)));
+ Table.States (222).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (53, 0), 1)));
+ Table.States (223).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (223), (8, 10, 14, 18, 20, 25, 27, 39),
(53, 1), 1);
+ Table.States (223).Kernel := To_Vector ((0 => ((53, 1), 74, 0,
(53, 1), 1)));
+ Table.States (223).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (53, 1), 1)));
+ Table.States (224).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (224), (34, 37), (57, 1), 3);
+ Table.States (224).Kernel := To_Vector ((0 => ((57, 1), 56, 0,
(57, 1), 3)));
+ Table.States (224).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (57, 1), 3)));
+ Table.States (225).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (225), (8, 10, 14, 18, 20, 25, 39), (47,
0), 7);
+ Table.States (225).Kernel := To_Vector ((0 => ((47, 0), 36, 0,
(47, 0), 7)));
+ Table.States (225).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (47, 0), 7)));
+ Table.States (226).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (226), 29, (58, 1), 170);
+ Add_Action (Table.States (226), 36, (44, 3), 253);
+ Table.States (226).Kernel := To_Vector ((((44, 3), 58, 1,
(32767, 0), 0), ((58, 1), 58, 1, (32767, 0),
+ 0)));
+ Table.States (226).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (44, 3), 36, 253)));
+ Table.States (227).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (227), 16, (43, 0), 254);
+ Table.States (227).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (227), 43, 255);
+ Table.States (227).Kernel := To_Vector ((0 => ((59, 0), 12, 2,
(32767, 0), 0)));
+ Table.States (227).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (43, 0), 16, 254)));
+ Table.States (228).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (228), 16, (43, 0), 254);
+ Table.States (228).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (228), 43, 256);
+ Table.States (228).Kernel := To_Vector ((0 => ((59, 1), 13, 2,
(32767, 0), 0)));
+ Table.States (228).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (43, 0), 16, 254)));
+ Table.States (229).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (229), 12, (59, 0), 32);
+ Add_Action (Table.States (229), 13, (59, 1), 33);
+ Add_Action (Table.States (229), 16, (43, 0), 34);
+ Add_Action (Table.States (229), 21, (45, 0), 9);
+ Add_Action (Table.States (229), 23, (73, 1), 257);
+ Add_Conflict (Table.States (229), 23, (60, 0), 0);
+ Add_Action (Table.States (229), 29, Reduce, (60, 0), 0);
+ Add_Action (Table.States (229), 32, Reduce, (60, 0), 0);
+ Add_Action (Table.States (229), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (229), 35, Reduce, (60, 0), 0);
+ Add_Action (Table.States (229), 39, (60, 1), 36);
+ Add_Action (Table.States (229), 40, (71, 0), 37);
+ Table.States (229).Goto_List.Set_Capacity (10);
+ Add_Goto (Table.States (229), 43, 38);
+ Add_Goto (Table.States (229), 45, 39);
+ Add_Goto (Table.States (229), 46, 40);
+ Add_Goto (Table.States (229), 58, 41);
+ Add_Goto (Table.States (229), 59, 42);
+ Add_Goto (Table.States (229), 60, 43);
+ Add_Goto (Table.States (229), 61, 44);
+ Add_Goto (Table.States (229), 71, 45);
+ Add_Goto (Table.States (229), 72, 258);
+ Add_Goto (Table.States (229), 73, 47);
+ Table.States (229).Kernel := To_Vector ((((43, 0), 16, 1,
(32767, 0), 0), ((73, 1), 16, 1, (32767, 0),
+ 0)));
+ Table.States (229).Minimal_Complete_Actions := To_Vector
(((Reduce, (72, 0), 0), (Shift, (73, 1), 23,
+ 257)));
+ Table.States (230).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (230), (6, 29, 33, 35, 36), (60, 1), 1);
+ Table.States (230).Kernel := To_Vector ((0 => ((60, 1), 39, 0,
(60, 1), 1)));
+ Table.States (230).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (60, 1), 1)));
+ Table.States (231).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (231), (6, 29, 36), (71, 0), 1);
+ Table.States (231).Kernel := To_Vector ((0 => ((71, 0), 40, 0,
(71, 0), 1)));
+ Table.States (231).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (71, 0), 1)));
+ Table.States (232).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (232), (6, 29, 36), (73, 2), 1);
+ Table.States (232).Kernel := To_Vector ((0 => ((73, 2), 43, 0,
(73, 2), 1)));
+ Table.States (232).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (73, 2), 1)));
+ Table.States (233).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (233), 35, (46, 0), 259);
+ Table.States (233).Kernel := To_Vector ((((46, 0), 45, 2,
(32767, 0), 0), ((46, 1), 45, 5, (32767, 0),
+ 0)));
+ Table.States (233).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (46, 0), 35, 259)));
+ Table.States (234).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (234), (6, 29, 36), (71, 3), 1);
+ Table.States (234).Kernel := To_Vector ((0 => ((71, 3), 46, 0,
(71, 3), 1)));
+ Table.States (234).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (71, 3), 1)));
+ Table.States (235).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (235), 6, (44, 2), 260);
+ Add_Action (Table.States (235), 29, (58, 1), 261);
+ Add_Action (Table.States (235), 36, (44, 1), 262);
+ Table.States (235).Kernel := To_Vector ((((44, 1), 58, 1,
(32767, 0), 0), ((44, 2), 58, 3, (32767, 0),
+ 0), ((58, 1), 58, 1, (32767, 0), 0)));
+ Table.States (235).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (44, 1), 36, 262)));
+ Table.States (236).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (236), (6, 29, 36), (71, 2), 1);
+ Table.States (236).Kernel := To_Vector ((0 => ((71, 2), 59, 0,
(71, 2), 1)));
+ Table.States (236).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (71, 2), 1)));
+ Table.States (237).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (237), (6, 29, 33, 35, 36), (61, 0), 1);
+ Table.States (237).Kernel := To_Vector ((0 => ((61, 0), 60, 0,
(61, 0), 1)));
+ Table.States (237).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (61, 0), 1)));
+ Table.States (238).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (238), 6, Reduce, (71, 1), 1);
+ Add_Action (Table.States (238), 29, Reduce, (71, 1), 1);
+ Add_Action (Table.States (238), 33, (61, 1), 263);
+ Add_Action (Table.States (238), 35, Reduce, (45, 1), 1);
+ Add_Action (Table.States (238), 36, Reduce, (71, 1), 1);
+ Table.States (238).Kernel := To_Vector ((((45, 1), 61, 0, (45,
1), 1), ((61, 1), 61, 2, (32767, 0),
+ 0), ((71, 1), 61, 0, (71, 1), 1)));
+ Table.States (238).Minimal_Complete_Actions := To_Vector
(((Reduce, (45, 1), 1), (Reduce, (71, 1), 1)));
+ Table.States (239).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (239), (6, 29, 36), (73, 0), 1);
+ Table.States (239).Kernel := To_Vector ((0 => ((73, 0), 71, 0,
(73, 0), 1)));
+ Table.States (239).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (73, 0), 1)));
+ Table.States (240).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (240), (6, 29, 36), (58, 0), 1);
+ Table.States (240).Kernel := To_Vector ((0 => ((58, 0), 73, 0,
(58, 0), 1)));
+ Table.States (240).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (58, 0), 1)));
+ Table.States (241).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (241), 36, Reduce, (60, 0), 0);
+ Add_Action (Table.States (241), 39, (60, 1), 144);
+ Table.States (241).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (241), 60, 264);
+ Table.States (241).Kernel := To_Vector ((0 => ((64, 0), 10, 1,
(32767, 0), 0)));
+ Table.States (241).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (60, 0), 0)));
+ Table.States (242).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (242), (8, 10, 14, 18, 20, 25, 39), (63,
0), 7);
+ Table.States (242).Kernel := To_Vector ((0 => ((63, 0), 36, 0,
(63, 0), 7)));
+ Table.States (242).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (63, 0), 7)));
+ Table.States (243).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (243), 23, (46, 1), 265);
+ Table.States (243).Kernel := To_Vector ((0 => ((46, 1), 40, 1,
(32767, 0), 0)));
+ Table.States (243).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (46, 1), 23, 265)));
+ Table.States (244).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (244), 15, (47, 0), 266);
+ Add_Action (Table.States (244), 33, (61, 1), 121);
+ Table.States (244).Kernel := To_Vector ((((47, 0), 61, 4,
(32767, 0), 0), ((61, 1), 61, 2, (32767, 0),
+ 0)));
+ Table.States (244).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (47, 0), 15, 266)));
+ Table.States (245).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (245), 16, (44, 3), 267);
+ Table.States (245).Kernel := To_Vector ((0 => ((44, 3), 12, 5,
(32767, 0), 0)));
+ Table.States (245).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (44, 3), 16, 267)));
+ Table.States (246).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (246), 16, (44, 1), 268);
+ Add_Action (Table.States (246), 26, (44, 0), 269);
+ Table.States (246).Kernel := To_Vector ((((44, 0), 39, 2,
(32767, 0), 0), ((44, 1), 39, 4, (32767, 0),
+ 0), ((44, 2), 39, 6, (32767, 0), 0)));
+ Table.States (246).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (44, 0), 26, 269)));
+ Table.States (247).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (247), (8, 10, 14, 18, 20, 25, 27, 39),
(69, 4), 2);
+ Table.States (247).Kernel := To_Vector ((0 => ((69, 4), 36, 0,
(69, 4), 2)));
+ Table.States (247).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (69, 4), 2)));
+ Table.States (248).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (248), 11, (64, 0), 270);
+ Add_Action (Table.States (248), 15, (63, 0), 271);
+ Add_Action (Table.States (248), 22, (65, 0), 272);
+ Table.States (248).Kernel := To_Vector ((((63, 0), 60, 3,
(32767, 0), 0), ((64, 0), 60, 4, (32767, 0),
+ 0), ((65, 0), 60, 2, (32767, 0), 0)));
+ Table.States (248).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (65, 0), 22, 272)));
+ Table.States (249).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (249), 15, (74, 0), 273);
+ Table.States (249).Kernel := To_Vector ((0 => ((74, 0), 39, 4,
(32767, 0), 0)));
+ Table.States (249).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (74, 0), 15, 273)));
+ Table.States (250).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (250), 39, (69, 1), 274);
+ Table.States (250).Kernel := To_Vector ((0 => ((69, 1), 30, 3,
(32767, 0), 0)));
+ Table.States (250).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (69, 1), 39, 274)));
+ Table.States (251).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (251), 12, (59, 0), 130);
+ Add_Action (Table.States (251), 13, (59, 1), 131);
+ Add_Action (Table.States (251), 16, (43, 0), 132);
+ Add_Action (Table.States (251), 21, (45, 0), 9);
+ Add_Action (Table.States (251), 29, Reduce, (60, 0), 0);
+ Add_Action (Table.States (251), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (251), 35, Reduce, (60, 0), 0);
+ Add_Action (Table.States (251), 36, Reduce, (60, 0), 0);
+ Add_Action (Table.States (251), 39, (60, 1), 133);
+ Add_Action (Table.States (251), 40, (71, 0), 134);
+ Table.States (251).Goto_List.Set_Capacity (9);
+ Add_Goto (Table.States (251), 43, 135);
+ Add_Goto (Table.States (251), 45, 136);
+ Add_Goto (Table.States (251), 46, 137);
+ Add_Goto (Table.States (251), 58, 275);
+ Add_Goto (Table.States (251), 59, 139);
+ Add_Goto (Table.States (251), 60, 140);
+ Add_Goto (Table.States (251), 61, 141);
+ Add_Goto (Table.States (251), 71, 142);
+ Add_Goto (Table.States (251), 73, 143);
+ Table.States (251).Kernel := To_Vector ((0 => ((69, 0), 31, 1,
(32767, 0), 0)));
+ Table.States (251).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (58, 0), 0)));
+ Table.States (252).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (252), (8, 10, 14, 18, 20, 25, 27, 39),
(54, 1), 2);
+ Table.States (252).Kernel := To_Vector ((0 => ((54, 1), 53, 0,
(54, 1), 2)));
+ Table.States (252).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (54, 1), 2)));
+ Table.States (253).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (253), (8, 10, 14, 18, 20, 25, 39), (44,
3), 8);
+ Table.States (253).Kernel := To_Vector ((0 => ((44, 3), 36, 0,
(44, 3), 8)));
+ Table.States (253).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (44, 3), 8)));
+ Table.States (254).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (254), 12, (59, 0), 32);
+ Add_Action (Table.States (254), 13, (59, 1), 33);
+ Add_Action (Table.States (254), 16, (43, 0), 34);
+ Add_Action (Table.States (254), 21, (45, 0), 9);
+ Add_Action (Table.States (254), 23, Reduce, (60, 0), 0);
+ Add_Action (Table.States (254), 29, Reduce, (60, 0), 0);
+ Add_Action (Table.States (254), 32, Reduce, (60, 0), 0);
+ Add_Action (Table.States (254), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (254), 35, Reduce, (60, 0), 0);
+ Add_Action (Table.States (254), 39, (60, 1), 36);
+ Add_Action (Table.States (254), 40, (71, 0), 37);
+ Table.States (254).Goto_List.Set_Capacity (10);
+ Add_Goto (Table.States (254), 43, 38);
+ Add_Goto (Table.States (254), 45, 39);
+ Add_Goto (Table.States (254), 46, 40);
+ Add_Goto (Table.States (254), 58, 41);
+ Add_Goto (Table.States (254), 59, 42);
+ Add_Goto (Table.States (254), 60, 43);
+ Add_Goto (Table.States (254), 61, 44);
+ Add_Goto (Table.States (254), 71, 45);
+ Add_Goto (Table.States (254), 72, 258);
+ Add_Goto (Table.States (254), 73, 47);
+ Table.States (254).Kernel := To_Vector ((0 => ((43, 0), 16, 1,
(32767, 0), 0)));
+ Table.States (254).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (72, 0), 0)));
+ Table.States (255).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (255), (6, 29, 36), (59, 0), 2);
+ Table.States (255).Kernel := To_Vector ((0 => ((59, 0), 43, 0,
(59, 0), 2)));
+ Table.States (255).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (59, 0), 2)));
+ Table.States (256).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (256), (6, 29, 36), (59, 1), 2);
+ Table.States (256).Kernel := To_Vector ((0 => ((59, 1), 43, 0,
(59, 1), 2)));
+ Table.States (256).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (59, 1), 2)));
+ Table.States (257).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (257), (6, 29, 36), (73, 1), 2);
+ Table.States (257).Kernel := To_Vector ((0 => ((73, 1), 23, 0,
(73, 1), 2)));
+ Table.States (257).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (73, 1), 2)));
+ Table.States (258).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (258), 23, (43, 0), 276);
+ Add_Action (Table.States (258), 32, (72, 1), 67);
+ Table.States (258).Kernel := To_Vector ((((43, 0), 72, 1,
(32767, 0), 0), ((72, 1), 72, 1, (32767, 0),
+ 0)));
+ Table.States (258).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (43, 0), 23, 276)));
+ Table.States (259).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (259), 39, (46, 0), 277);
+ Table.States (259).Kernel := To_Vector ((((46, 0), 35, 1,
(32767, 0), 0), ((46, 1), 35, 4, (32767, 0),
+ 0)));
+ Table.States (259).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (46, 0), 39, 277)));
+ Table.States (260).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (260), 38, (44, 2), 278);
+ Table.States (260).Kernel := To_Vector ((0 => ((44, 2), 6, 2,
(32767, 0), 0)));
+ Table.States (260).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (44, 2), 38, 278)));
+ Table.States (261).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (261), 6, Reduce, (60, 0), 0);
+ Add_Action (Table.States (261), 12, (59, 0), 227);
+ Add_Action (Table.States (261), 13, (59, 1), 228);
+ Add_Action (Table.States (261), 16, (43, 0), 229);
+ Add_Action (Table.States (261), 21, (45, 0), 9);
+ Add_Action (Table.States (261), 29, Reduce, (60, 0), 0);
+ Add_Action (Table.States (261), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (261), 35, Reduce, (60, 0), 0);
+ Add_Action (Table.States (261), 36, Reduce, (60, 0), 0);
+ Add_Action (Table.States (261), 39, (60, 1), 230);
+ Add_Action (Table.States (261), 40, (71, 0), 231);
+ Table.States (261).Goto_List.Set_Capacity (8);
+ Add_Goto (Table.States (261), 43, 232);
+ Add_Goto (Table.States (261), 45, 233);
+ Add_Goto (Table.States (261), 46, 234);
+ Add_Goto (Table.States (261), 59, 236);
+ Add_Goto (Table.States (261), 60, 237);
+ Add_Goto (Table.States (261), 61, 238);
+ Add_Goto (Table.States (261), 71, 239);
+ Add_Goto (Table.States (261), 73, 279);
+ Table.States (261).Kernel := To_Vector ((0 => ((58, 1), 29, 0,
(73, 0), 0)));
+ Table.States (261).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (73, 0), 0)));
+ Table.States (262).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (262), (8, 10, 14, 18, 20, 25, 39), (44,
1), 8);
+ Table.States (262).Kernel := To_Vector ((0 => ((44, 1), 36, 0,
(44, 1), 8)));
+ Table.States (262).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (44, 1), 8)));
+ Table.States (263).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (263), 39, (61, 1), 280);
+ Table.States (263).Kernel := To_Vector ((0 => ((61, 1), 33, 1,
(32767, 0), 0)));
+ Table.States (263).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (61, 1), 39, 280)));
+ Table.States (264).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (264), 36, (64, 0), 281);
+ Table.States (264).Kernel := To_Vector ((0 => ((64, 0), 60, 1,
(32767, 0), 0)));
+ Table.States (264).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (64, 0), 36, 281)));
+ end Subr_5;
+ procedure Subr_6
+ is begin
+ Table.States (265).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (265), (29, 36), (46, 1), 6);
+ Table.States (265).Kernel := To_Vector ((0 => ((46, 1), 23, 0,
(46, 1), 6)));
+ Table.States (265).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (46, 1), 6)));
+ Table.States (266).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (266), 10, Reduce, (49, 0), 0);
+ Add_Action (Table.States (266), 27, (48, 0), 147);
+ Add_Conflict (Table.States (266), 27, (49, 0), 0);
+ Table.States (266).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (266), 48, 148);
+ Add_Goto (Table.States (266), 49, 282);
+ Table.States (266).Kernel := To_Vector ((0 => ((47, 0), 15, 3,
(32767, 0), 0)));
+ Table.States (266).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (49, 0), 0)));
+ Table.States (267).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (267), 40, (44, 3), 283);
+ Table.States (267).Kernel := To_Vector ((0 => ((44, 3), 16, 4,
(32767, 0), 0)));
+ Table.States (267).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (44, 3), 40, 283)));
+ Table.States (268).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (268), 19, (56, 2), 152);
+ Add_Action (Table.States (268), 23, Reduce, (56, 0), 0);
+ Add_Action (Table.States (268), 40, (56, 1), 153);
+ Table.States (268).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (268), 56, 284);
+ Table.States (268).Kernel := To_Vector ((((44, 1), 16, 3,
(32767, 0), 0), ((44, 2), 16, 5, (32767, 0),
+ 0)));
+ Table.States (268).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (56, 0), 0)));
+ Table.States (269).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (269), 12, (59, 0), 130);
+ Add_Action (Table.States (269), 13, (59, 1), 131);
+ Add_Action (Table.States (269), 16, (43, 0), 132);
+ Add_Action (Table.States (269), 21, (45, 0), 9);
+ Add_Action (Table.States (269), 29, Reduce, (60, 0), 0);
+ Add_Action (Table.States (269), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (269), 35, Reduce, (60, 0), 0);
+ Add_Action (Table.States (269), 36, Reduce, (60, 0), 0);
+ Add_Action (Table.States (269), 39, (60, 1), 133);
+ Add_Action (Table.States (269), 40, (71, 0), 134);
+ Table.States (269).Goto_List.Set_Capacity (9);
+ Add_Goto (Table.States (269), 43, 135);
+ Add_Goto (Table.States (269), 45, 136);
+ Add_Goto (Table.States (269), 46, 137);
+ Add_Goto (Table.States (269), 58, 285);
+ Add_Goto (Table.States (269), 59, 139);
+ Add_Goto (Table.States (269), 60, 140);
+ Add_Goto (Table.States (269), 61, 141);
+ Add_Goto (Table.States (269), 71, 142);
+ Add_Goto (Table.States (269), 73, 143);
+ Table.States (269).Kernel := To_Vector ((0 => ((44, 0), 26, 1,
(32767, 0), 0)));
+ Table.States (269).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (58, 0), 0)));
+ Table.States (270).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (270), 15, Reduce, (60, 0), 0);
+ Add_Action (Table.States (270), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (270), 39, (60, 1), 105);
+ Table.States (270).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (270), 60, 106);
+ Add_Goto (Table.States (270), 61, 286);
+ Table.States (270).Kernel := To_Vector ((0 => ((64, 0), 11, 3,
(32767, 0), 0)));
+ Table.States (270).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (61, 0), 0)));
+ Table.States (271).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (271), 8, (47, 0), 85);
+ Add_Action (Table.States (271), 10, Reduce, (55, 0), 0);
+ Add_Action (Table.States (271), 14, (44, 0), 86);
+ Add_Action (Table.States (271), 18, (69, 4), 87);
+ Add_Action (Table.States (271), 20, (63, 0), 88);
+ Add_Action (Table.States (271), 25, (74, 0), 89);
+ Add_Action (Table.States (271), 39, (69, 0), 90);
+ Table.States (271).Goto_List.Set_Capacity (11);
+ Add_Goto (Table.States (271), 44, 91);
+ Add_Goto (Table.States (271), 47, 92);
+ Add_Goto (Table.States (271), 53, 93);
+ Add_Goto (Table.States (271), 54, 94);
+ Add_Goto (Table.States (271), 55, 287);
+ Add_Goto (Table.States (271), 62, 96);
+ Add_Goto (Table.States (271), 63, 97);
+ Add_Goto (Table.States (271), 64, 98);
+ Add_Goto (Table.States (271), 65, 99);
+ Add_Goto (Table.States (271), 69, 100);
+ Add_Goto (Table.States (271), 74, 101);
+ Table.States (271).Kernel := To_Vector ((0 => ((63, 0), 15, 2,
(32767, 0), 0)));
+ Table.States (271).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (55, 0), 0)));
+ Table.States (272).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (272), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (272), 36, Reduce, (60, 0), 0);
+ Add_Action (Table.States (272), 39, (60, 1), 158);
+ Table.States (272).Goto_List.Set_Capacity (2);
+ Add_Goto (Table.States (272), 60, 159);
+ Add_Goto (Table.States (272), 61, 288);
+ Table.States (272).Kernel := To_Vector ((0 => ((65, 0), 22, 1,
(32767, 0), 0)));
+ Table.States (272).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (61, 0), 0)));
+ Table.States (273).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (273), 16, (43, 0), 161);
+ Table.States (273).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (273), 43, 289);
+ Table.States (273).Kernel := To_Vector ((0 => ((74, 0), 15, 3,
(32767, 0), 0)));
+ Table.States (273).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (43, 0), 16, 161)));
+ Table.States (274).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (274), 31, (69, 1), 290);
+ Table.States (274).Kernel := To_Vector ((0 => ((69, 1), 39, 2,
(32767, 0), 0)));
+ Table.States (274).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (69, 1), 31, 290)));
+ Table.States (275).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (275), 29, (58, 1), 170);
+ Add_Action (Table.States (275), 36, (69, 0), 291);
+ Table.States (275).Kernel := To_Vector ((((58, 1), 58, 1,
(32767, 0), 0), ((69, 0), 58, 1, (32767, 0),
+ 0)));
+ Table.States (275).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (69, 0), 36, 291)));
+ Table.States (276).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (276), (6, 29, 36), (43, 0), 3);
+ Table.States (276).Kernel := To_Vector ((0 => ((43, 0), 23, 0,
(43, 0), 3)));
+ Table.States (276).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (43, 0), 3)));
+ Table.States (277).Action_List.Set_Capacity (4);
+ Add_Action (Table.States (277), 6, Reduce, (46, 0), 3);
+ Add_Action (Table.States (277), 16, (46, 1), 292);
+ Add_Action (Table.States (277), 29, Reduce, (46, 0), 3);
+ Add_Action (Table.States (277), 36, Reduce, (46, 0), 3);
+ Table.States (277).Kernel := To_Vector ((((46, 0), 39, 0, (46,
0), 3), ((46, 1), 39, 3, (32767, 0),
+ 0)));
+ Table.States (277).Minimal_Complete_Actions := To_Vector
(((Reduce, (46, 0), 3), (Shift, (46, 1), 16,
+ 292)));
+ Table.States (278).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (278), 36, (44, 2), 293);
+ Table.States (278).Kernel := To_Vector ((0 => ((44, 2), 38, 1,
(32767, 0), 0)));
+ Table.States (278).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (44, 2), 36, 293)));
+ Table.States (279).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (279), (6, 29, 36), (58, 1), 3);
+ Table.States (279).Kernel := To_Vector ((0 => ((58, 1), 73, 0,
(58, 1), 3)));
+ Table.States (279).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (58, 1), 3)));
+ Table.States (280).Action_List.Set_Capacity (5);
+ Add_Action (Table.States (280), (6, 29, 33, 35, 36), (61, 1), 3);
+ Table.States (280).Kernel := To_Vector ((0 => ((61, 1), 39, 0,
(61, 1), 3)));
+ Table.States (280).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (61, 1), 3)));
+ Table.States (281).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (281), (8, 10, 14, 18, 20, 25, 39), (64,
0), 9);
+ Table.States (281).Kernel := To_Vector ((0 => ((64, 0), 36, 0,
(64, 0), 9)));
+ Table.States (281).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (64, 0), 9)));
+ Table.States (282).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (282), 10, (47, 0), 294);
+ Add_Action (Table.States (282), 27, (48, 0), 147);
+ Table.States (282).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (282), 48, 180);
+ Table.States (282).Kernel := To_Vector ((((47, 0), 49, 3,
(32767, 0), 0), ((49, 2), 49, 2, (32767, 0),
+ 0)));
+ Table.States (282).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (47, 0), 10, 294)));
+ Table.States (283).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (283), 23, (44, 3), 295);
+ Table.States (283).Kernel := To_Vector ((0 => ((44, 3), 40, 3,
(32767, 0), 0)));
+ Table.States (283).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (44, 3), 23, 295)));
+ Table.States (284).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (284), 23, (44, 1), 296);
+ Table.States (284).Kernel := To_Vector ((((44, 1), 56, 3,
(32767, 0), 0), ((44, 2), 56, 5, (32767, 0),
+ 0)));
+ Table.States (284).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (44, 1), 23, 296)));
+ Table.States (285).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (285), 29, (58, 1), 170);
+ Add_Action (Table.States (285), 36, (44, 0), 297);
+ Table.States (285).Kernel := To_Vector ((((44, 0), 58, 1,
(32767, 0), 0), ((58, 1), 58, 1, (32767, 0),
+ 0)));
+ Table.States (285).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (44, 0), 36, 297)));
+ Table.States (286).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (286), 15, (64, 0), 298);
+ Add_Action (Table.States (286), 33, (61, 1), 121);
+ Table.States (286).Kernel := To_Vector ((((61, 1), 61, 2,
(32767, 0), 0), ((64, 0), 61, 3, (32767, 0),
+ 0)));
+ Table.States (286).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (64, 0), 15, 298)));
+ Table.States (287).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (287), 10, (63, 0), 299);
+ Table.States (287).Kernel := To_Vector ((0 => ((63, 0), 55, 2,
(32767, 0), 0)));
+ Table.States (287).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (63, 0), 10, 299)));
+ Table.States (288).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (288), 33, (61, 1), 186);
+ Add_Action (Table.States (288), 36, (65, 0), 300);
+ Table.States (288).Kernel := To_Vector ((((61, 1), 61, 2,
(32767, 0), 0), ((65, 0), 61, 1, (32767, 0),
+ 0)));
+ Table.States (288).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (65, 0), 36, 300)));
+ Table.States (289).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (289), 36, (74, 0), 301);
+ Table.States (289).Kernel := To_Vector ((0 => ((74, 0), 43, 1,
(32767, 0), 0)));
+ Table.States (289).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (74, 0), 36, 301)));
+ Table.States (290).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (290), 12, (59, 0), 130);
+ Add_Action (Table.States (290), 13, (59, 1), 131);
+ Add_Action (Table.States (290), 16, (43, 0), 132);
+ Add_Action (Table.States (290), 21, (45, 0), 9);
+ Add_Action (Table.States (290), 29, Reduce, (60, 0), 0);
+ Add_Action (Table.States (290), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (290), 35, Reduce, (60, 0), 0);
+ Add_Action (Table.States (290), 36, Reduce, (60, 0), 0);
+ Add_Action (Table.States (290), 39, (60, 1), 133);
+ Add_Action (Table.States (290), 40, (71, 0), 134);
+ Table.States (290).Goto_List.Set_Capacity (9);
+ Add_Goto (Table.States (290), 43, 135);
+ Add_Goto (Table.States (290), 45, 136);
+ Add_Goto (Table.States (290), 46, 137);
+ Add_Goto (Table.States (290), 58, 302);
+ Add_Goto (Table.States (290), 59, 139);
+ Add_Goto (Table.States (290), 60, 140);
+ Add_Goto (Table.States (290), 61, 141);
+ Add_Goto (Table.States (290), 71, 142);
+ Add_Goto (Table.States (290), 73, 143);
+ Table.States (290).Kernel := To_Vector ((0 => ((69, 1), 31, 1,
(32767, 0), 0)));
+ Table.States (290).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (58, 0), 0)));
+ Table.States (291).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (291), (8, 10, 14, 18, 20, 25, 27, 39),
(69, 0), 4);
+ Table.States (291).Kernel := To_Vector ((0 => ((69, 0), 36, 0,
(69, 0), 4)));
+ Table.States (291).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (69, 0), 4)));
+ Table.States (292).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (292), 40, (46, 1), 303);
+ Table.States (292).Kernel := To_Vector ((0 => ((46, 1), 16, 2,
(32767, 0), 0)));
+ Table.States (292).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (46, 1), 40, 303)));
+ Table.States (293).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (293), (8, 10, 14, 18, 20, 25, 39), (44,
2), 10);
+ Table.States (293).Kernel := To_Vector ((0 => ((44, 2), 36, 0,
(44, 2), 10)));
+ Table.States (293).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (44, 2), 10)));
+ Table.States (294).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (294), 8, (47, 0), 304);
+ Table.States (294).Kernel := To_Vector ((0 => ((47, 0), 10, 2,
(32767, 0), 0)));
+ Table.States (294).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (47, 0), 8, 304)));
+ Table.States (295).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (295), 26, (44, 3), 305);
+ Table.States (295).Kernel := To_Vector ((0 => ((44, 3), 23, 2,
(32767, 0), 0)));
+ Table.States (295).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (44, 3), 26, 305)));
+ Table.States (296).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (296), 26, (44, 1), 306);
+ Table.States (296).Kernel := To_Vector ((((44, 1), 23, 2,
(32767, 0), 0), ((44, 2), 23, 4, (32767, 0),
+ 0)));
+ Table.States (296).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (44, 1), 26, 306)));
+ Table.States (297).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (297), (8, 10, 14, 18, 20, 25, 27, 39),
(44, 0), 5);
+ Table.States (297).Kernel := To_Vector ((0 => ((44, 0), 36, 0,
(44, 0), 5)));
+ Table.States (297).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (44, 0), 5)));
+ Table.States (298).Action_List.Set_Capacity (7);
+ Add_Action (Table.States (298), 8, (47, 0), 85);
+ Add_Action (Table.States (298), 10, Reduce, (55, 0), 0);
+ Add_Action (Table.States (298), 14, (44, 0), 86);
+ Add_Action (Table.States (298), 18, (69, 4), 87);
+ Add_Action (Table.States (298), 20, (63, 0), 88);
+ Add_Action (Table.States (298), 25, (74, 0), 89);
+ Add_Action (Table.States (298), 39, (69, 0), 90);
+ Table.States (298).Goto_List.Set_Capacity (11);
+ Add_Goto (Table.States (298), 44, 91);
+ Add_Goto (Table.States (298), 47, 92);
+ Add_Goto (Table.States (298), 53, 93);
+ Add_Goto (Table.States (298), 54, 94);
+ Add_Goto (Table.States (298), 55, 307);
+ Add_Goto (Table.States (298), 62, 96);
+ Add_Goto (Table.States (298), 63, 97);
+ Add_Goto (Table.States (298), 64, 98);
+ Add_Goto (Table.States (298), 65, 99);
+ Add_Goto (Table.States (298), 69, 100);
+ Add_Goto (Table.States (298), 74, 101);
+ Table.States (298).Kernel := To_Vector ((0 => ((64, 0), 15, 2,
(32767, 0), 0)));
+ Table.States (298).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (55, 0), 0)));
+ Table.States (299).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (299), 36, Reduce, (60, 0), 0);
+ Add_Action (Table.States (299), 39, (60, 1), 144);
+ Table.States (299).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (299), 60, 308);
+ Table.States (299).Kernel := To_Vector ((0 => ((63, 0), 10, 1,
(32767, 0), 0)));
+ Table.States (299).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (60, 0), 0)));
+ Table.States (300).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (300), (8, 10, 14, 18, 20, 25, 27, 39),
(65, 0), 5);
+ Table.States (300).Kernel := To_Vector ((0 => ((65, 0), 36, 0,
(65, 0), 5)));
+ Table.States (300).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (65, 0), 5)));
+ Table.States (301).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (301), (8, 10, 14, 18, 20, 25, 27, 39),
(74, 0), 5);
+ Table.States (301).Kernel := To_Vector ((0 => ((74, 0), 36, 0,
(74, 0), 5)));
+ Table.States (301).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (74, 0), 5)));
+ Table.States (302).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (302), 29, (58, 1), 170);
+ Add_Action (Table.States (302), 36, (69, 1), 309);
+ Table.States (302).Kernel := To_Vector ((((58, 1), 58, 1,
(32767, 0), 0), ((69, 1), 58, 1, (32767, 0),
+ 0)));
+ Table.States (302).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (69, 1), 36, 309)));
+ Table.States (303).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (303), 23, (46, 1), 310);
+ Table.States (303).Kernel := To_Vector ((0 => ((46, 1), 40, 1,
(32767, 0), 0)));
+ Table.States (303).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (46, 1), 23, 310)));
+ Table.States (304).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (304), 36, (47, 0), 311);
+ Table.States (304).Kernel := To_Vector ((0 => ((47, 0), 8, 1,
(32767, 0), 0)));
+ Table.States (304).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (47, 0), 36, 311)));
+ Table.States (305).Action_List.Set_Capacity (10);
+ Add_Action (Table.States (305), 12, (59, 0), 130);
+ Add_Action (Table.States (305), 13, (59, 1), 131);
+ Add_Action (Table.States (305), 16, (43, 0), 132);
+ Add_Action (Table.States (305), 21, (45, 0), 9);
+ Add_Action (Table.States (305), 29, Reduce, (60, 0), 0);
+ Add_Action (Table.States (305), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (305), 35, Reduce, (60, 0), 0);
+ Add_Action (Table.States (305), 36, Reduce, (60, 0), 0);
+ Add_Action (Table.States (305), 39, (60, 1), 133);
+ Add_Action (Table.States (305), 40, (71, 0), 134);
+ Table.States (305).Goto_List.Set_Capacity (9);
+ Add_Goto (Table.States (305), 43, 135);
+ Add_Goto (Table.States (305), 45, 136);
+ Add_Goto (Table.States (305), 46, 137);
+ Add_Goto (Table.States (305), 58, 312);
+ Add_Goto (Table.States (305), 59, 139);
+ Add_Goto (Table.States (305), 60, 140);
+ Add_Goto (Table.States (305), 61, 141);
+ Add_Goto (Table.States (305), 71, 142);
+ Add_Goto (Table.States (305), 73, 143);
+ Table.States (305).Kernel := To_Vector ((0 => ((44, 3), 26, 1,
(32767, 0), 0)));
+ Table.States (305).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (58, 0), 0)));
+ Table.States (306).Action_List.Set_Capacity (11);
+ Add_Action (Table.States (306), 6, Reduce, (60, 0), 0);
+ Add_Action (Table.States (306), 12, (59, 0), 227);
+ Add_Action (Table.States (306), 13, (59, 1), 228);
+ Add_Action (Table.States (306), 16, (43, 0), 229);
+ Add_Action (Table.States (306), 21, (45, 0), 9);
+ Add_Action (Table.States (306), 29, Reduce, (60, 0), 0);
+ Add_Action (Table.States (306), 33, Reduce, (60, 0), 0);
+ Add_Action (Table.States (306), 35, Reduce, (60, 0), 0);
+ Add_Action (Table.States (306), 36, Reduce, (60, 0), 0);
+ Add_Action (Table.States (306), 39, (60, 1), 230);
+ Add_Action (Table.States (306), 40, (71, 0), 231);
+ Table.States (306).Goto_List.Set_Capacity (9);
+ Add_Goto (Table.States (306), 43, 232);
+ Add_Goto (Table.States (306), 45, 233);
+ Add_Goto (Table.States (306), 46, 234);
+ Add_Goto (Table.States (306), 58, 313);
+ Add_Goto (Table.States (306), 59, 236);
+ Add_Goto (Table.States (306), 60, 237);
+ Add_Goto (Table.States (306), 61, 238);
+ Add_Goto (Table.States (306), 71, 239);
+ Add_Goto (Table.States (306), 73, 240);
+ Table.States (306).Kernel := To_Vector ((((44, 1), 26, 1,
(32767, 0), 0), ((44, 2), 26, 3, (32767, 0),
+ 0)));
+ Table.States (306).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (58, 0), 0)));
+ Table.States (307).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (307), 10, (64, 0), 314);
+ Table.States (307).Kernel := To_Vector ((0 => ((64, 0), 55, 2,
(32767, 0), 0)));
+ Table.States (307).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (64, 0), 10, 314)));
+ Table.States (308).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (308), 36, (63, 0), 315);
+ Table.States (308).Kernel := To_Vector ((0 => ((63, 0), 60, 1,
(32767, 0), 0)));
+ Table.States (308).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (63, 0), 36, 315)));
+ Table.States (309).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (309), (8, 10, 14, 18, 20, 25, 27, 39),
(69, 1), 6);
+ Table.States (309).Kernel := To_Vector ((0 => ((69, 1), 36, 0,
(69, 1), 6)));
+ Table.States (309).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (69, 1), 6)));
+ Table.States (310).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (310), (6, 29, 36), (46, 1), 6);
+ Table.States (310).Kernel := To_Vector ((0 => ((46, 1), 23, 0,
(46, 1), 6)));
+ Table.States (310).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (46, 1), 6)));
+ Table.States (311).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (311), (8, 10, 14, 18, 20, 25, 27, 39),
(47, 0), 7);
+ Table.States (311).Kernel := To_Vector ((0 => ((47, 0), 36, 0,
(47, 0), 7)));
+ Table.States (311).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (47, 0), 7)));
+ Table.States (312).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (312), 29, (58, 1), 170);
+ Add_Action (Table.States (312), 36, (44, 3), 316);
+ Table.States (312).Kernel := To_Vector ((((44, 3), 58, 1,
(32767, 0), 0), ((58, 1), 58, 1, (32767, 0),
+ 0)));
+ Table.States (312).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (44, 3), 36, 316)));
+ Table.States (313).Action_List.Set_Capacity (3);
+ Add_Action (Table.States (313), 6, (44, 2), 317);
+ Add_Action (Table.States (313), 29, (58, 1), 261);
+ Add_Action (Table.States (313), 36, (44, 1), 318);
+ Table.States (313).Kernel := To_Vector ((((44, 1), 58, 1,
(32767, 0), 0), ((44, 2), 58, 3, (32767, 0),
+ 0), ((58, 1), 58, 1, (32767, 0), 0)));
+ Table.States (313).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (44, 1), 36, 318)));
+ Table.States (314).Action_List.Set_Capacity (2);
+ Add_Action (Table.States (314), 36, Reduce, (60, 0), 0);
+ Add_Action (Table.States (314), 39, (60, 1), 144);
+ Table.States (314).Goto_List.Set_Capacity (1);
+ Add_Goto (Table.States (314), 60, 319);
+ Table.States (314).Kernel := To_Vector ((0 => ((64, 0), 10, 1,
(32767, 0), 0)));
+ Table.States (314).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (60, 0), 0)));
+ Table.States (315).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (315), (8, 10, 14, 18, 20, 25, 27, 39),
(63, 0), 7);
+ Table.States (315).Kernel := To_Vector ((0 => ((63, 0), 36, 0,
(63, 0), 7)));
+ Table.States (315).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (63, 0), 7)));
+ Table.States (316).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (316), (8, 10, 14, 18, 20, 25, 27, 39),
(44, 3), 8);
+ Table.States (316).Kernel := To_Vector ((0 => ((44, 3), 36, 0,
(44, 3), 8)));
+ Table.States (316).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (44, 3), 8)));
+ end Subr_6;
+ procedure Subr_7
+ is begin
+ Table.States (317).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (317), 38, (44, 2), 320);
+ Table.States (317).Kernel := To_Vector ((0 => ((44, 2), 6, 2,
(32767, 0), 0)));
+ Table.States (317).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (44, 2), 38, 320)));
+ Table.States (318).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (318), (8, 10, 14, 18, 20, 25, 27, 39),
(44, 1), 8);
+ Table.States (318).Kernel := To_Vector ((0 => ((44, 1), 36, 0,
(44, 1), 8)));
+ Table.States (318).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (44, 1), 8)));
+ Table.States (319).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (319), 36, (64, 0), 321);
+ Table.States (319).Kernel := To_Vector ((0 => ((64, 0), 60, 1,
(32767, 0), 0)));
+ Table.States (319).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (64, 0), 36, 321)));
+ Table.States (320).Action_List.Set_Capacity (1);
+ Add_Action (Table.States (320), 36, (44, 2), 322);
+ Table.States (320).Kernel := To_Vector ((0 => ((44, 2), 38, 1,
(32767, 0), 0)));
+ Table.States (320).Minimal_Complete_Actions := To_Vector ((0 =>
(Shift, (44, 2), 36, 322)));
+ Table.States (321).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (321), (8, 10, 14, 18, 20, 25, 27, 39),
(64, 0), 9);
+ Table.States (321).Kernel := To_Vector ((0 => ((64, 0), 36, 0,
(64, 0), 9)));
+ Table.States (321).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (64, 0), 9)));
+ Table.States (322).Action_List.Set_Capacity (8);
+ Add_Action (Table.States (322), (8, 10, 14, 18, 20, 25, 27, 39),
(44, 2), 10);
+ Table.States (322).Kernel := To_Vector ((0 => ((44, 2), 36, 0,
(44, 2), 10)));
+ Table.States (322).Minimal_Complete_Actions := To_Vector ((0 =>
(Reduce, (44, 2), 10)));
+ end Subr_7;
+ begin
+ Subr_1;
+ Subr_2;
+ Subr_3;
+ Subr_4;
+ Subr_5;
+ Subr_6;
+ Subr_7;
+ Table.Error_Action := new Parse_Action_Node'((Verb => Error, others
=> <>), null);
+ end;
+
+ Table.Error_Recover_Enabled := True;
+ Table.McKenzie_Param := McKenzie_Param;
+ Table.Max_Parallel := 15;
+ return Table;
+ end Create_Parse_Table;
+
+ function Create_Productions return
WisiToken.Syntax_Trees.Production_Info_Trees.Vector
+ is begin
+ return Result : WisiToken.Syntax_Trees.Production_Info_Trees.Vector do
+ Result.Set_First_Last (42, 75);
+ Result (43).RHSs.Set_First_Last (0, 0);
+ Result (43).RHSs (0).In_Parse_Action := null;
+ Result (43).RHSs (0).Post_Parse_Action := aggregate_g_0'Access;
+ Result (44).RHSs.Set_First_Last (0, 3);
+ Result (44).RHSs (0).In_Parse_Action := null;
+ Result (44).RHSs (0).Post_Parse_Action :=
attribute_declaration_0'Access;
+ Result (44).RHSs (1).In_Parse_Action := null;
+ Result (44).RHSs (1).Post_Parse_Action :=
attribute_declaration_1'Access;
+ Result (44).RHSs (2).In_Parse_Action := null;
+ Result (44).RHSs (2).Post_Parse_Action :=
attribute_declaration_2'Access;
+ Result (44).RHSs (3).In_Parse_Action := null;
+ Result (44).RHSs (3).Post_Parse_Action :=
attribute_declaration_3'Access;
+ Result (47).RHSs.Set_First_Last (0, 0);
+ Result (47).RHSs (0).In_Parse_Action := null;
+ Result (47).RHSs (0).Post_Parse_Action := case_statement_0'Access;
+ Result (48).RHSs.Set_First_Last (0, 0);
+ Result (48).RHSs (0).In_Parse_Action := null;
+ Result (48).RHSs (0).Post_Parse_Action := case_item_0'Access;
+ Result (50).RHSs.Set_First_Last (0, 0);
+ Result (50).RHSs (0).In_Parse_Action := null;
+ Result (50).RHSs (0).Post_Parse_Action := compilation_unit_0'Access;
+ Result (60).RHSs.Set_First_Last (0, 1);
+ Result (60).RHSs (0).In_Parse_Action := null;
+ Result (60).RHSs (0).Post_Parse_Action := null;
+ Result (60).RHSs (1).In_Parse_Action := identifier_opt_1_check'Access;
+ Result (60).RHSs (1).Post_Parse_Action := null;
+ Result (63).RHSs.Set_First_Last (0, 0);
+ Result (63).RHSs (0).In_Parse_Action := package_spec_0_check'Access;
+ Result (63).RHSs (0).Post_Parse_Action := package_spec_0'Access;
+ Result (64).RHSs.Set_First_Last (0, 0);
+ Result (64).RHSs (0).In_Parse_Action :=
package_extension_0_check'Access;
+ Result (64).RHSs (0).Post_Parse_Action := package_extension_0'Access;
+ Result (65).RHSs.Set_First_Last (0, 0);
+ Result (65).RHSs (0).In_Parse_Action := null;
+ Result (65).RHSs (0).Post_Parse_Action := package_renaming_0'Access;
+ Result (67).RHSs.Set_First_Last (0, 0);
+ Result (67).RHSs (0).In_Parse_Action :=
project_extension_0_check'Access;
+ Result (67).RHSs (0).Post_Parse_Action := project_extension_0'Access;
+ Result (69).RHSs.Set_First_Last (0, 4);
+ Result (69).RHSs (0).In_Parse_Action := null;
+ Result (69).RHSs (0).Post_Parse_Action :=
simple_declarative_item_0'Access;
+ Result (69).RHSs (1).In_Parse_Action := null;
+ Result (69).RHSs (1).Post_Parse_Action :=
simple_declarative_item_1'Access;
+ Result (69).RHSs (2).In_Parse_Action := null;
+ Result (69).RHSs (2).Post_Parse_Action := null;
+ Result (69).RHSs (3).In_Parse_Action := null;
+ Result (69).RHSs (3).Post_Parse_Action := null;
+ Result (69).RHSs (4).In_Parse_Action := null;
+ Result (69).RHSs (4).Post_Parse_Action :=
simple_declarative_item_4'Access;
+ Result (70).RHSs.Set_First_Last (0, 0);
+ Result (70).RHSs (0).In_Parse_Action :=
simple_project_declaration_0_check'Access;
+ Result (70).RHSs (0).Post_Parse_Action :=
simple_project_declaration_0'Access;
+ Result (74).RHSs.Set_First_Last (0, 0);
+ Result (74).RHSs (0).In_Parse_Action := null;
+ Result (74).RHSs (0).Post_Parse_Action :=
typed_string_declaration_0'Access;
+ end return;
+ end Create_Productions;
+
+ function Create_Parser
+ (Trace : in WisiToken.Trace_Access;
+ User_Data : in WisiToken.Syntax_Trees.User_Data_Access;
+ 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)
+ return WisiToken.Parse.LR.Parser.Parser
+ is begin
+ return Parser : WisiToken.Parse.LR.Parser.Parser do
+ Parser.Tree.Lexer := Lexer.New_Lexer (Trace,
Gpr_Process_Actions.Descriptor'Access);
+ Parser.Productions := Create_Productions;
+ Parser.User_Data := User_Data;
+ Parser.Partial_Parse_Active :=
Gpr_Process_Actions.Partial_Parse_Active'Access;
+ Parser.Partial_Parse_Byte_Goal :=
Gpr_Process_Actions.Partial_Parse_Byte_Goal'Access;
+ Parser.Table := Create_Parse_Table;
+ Parser.Language_Fixes := Language_Fixes;
+ Parser.Language_Matching_Begin_Tokens :=
Language_Matching_Begin_Tokens;
+ Parser.Language_String_ID_Set := Language_String_ID_Set;
+ end return;
+ end Create_Parser;
+end Gpr_Process_Main;
diff --git a/gpr_process_main.ads b/gpr_process_main.ads
new file mode 100644
index 0000000000..0bccb8db91
--- /dev/null
+++ b/gpr_process_main.ads
@@ -0,0 +1,32 @@
+-- generated parser support file. -*- buffer-read-only:t -*-
+-- command line: wisitoken-bnf-generate.exe --generate LR1 Ada_Emacs re2c
PROCESS gpr.wy
+--
+
+-- Copyright (C) 2013 - 2022 Free Software Foundation, Inc.
+
+-- This program is free software; you can redistribute it and/or
+-- modify it under the terms of the GNU General Public License as
+-- published by the Free Software Foundation; either version 3, or (at
+-- your option) any later version.
+--
+-- This software is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of
+-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+-- General Public License for more details.
+--
+-- You should have received a copy of the GNU General Public License
+-- along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
+
+with WisiToken.Syntax_Trees;
+with WisiToken.Parse.LR.Parser;
+package Gpr_Process_Main is
+
+ function Create_Parser
+ (Trace : in WisiToken.Trace_Access;
+ User_Data : in WisiToken.Syntax_Trees.User_Data_Access;
+ 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)
+ return WisiToken.Parse.LR.Parser.Parser;
+
+end Gpr_Process_Main;
diff --git a/gpr_re2c.c b/gpr_re2c.c
new file mode 100644
index 0000000000..2729c40fa2
--- /dev/null
+++ b/gpr_re2c.c
@@ -0,0 +1,7693 @@
+/* Generated by re2c 2.2 */
+#line 1 "../gpr.re2c"
+// generated parser support file. -*- buffer-read-only:t mode: C -*-
+// command line: wisitoken-bnf-generate.exe --generate LR1 Ada_Emacs re2c
PROCESS gpr.wy
+//
+
+// Copyright (C) 2013 - 2022 Free Software Foundation, Inc.
+
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3, or (at
+// your option) any later version.
+//
+// This software is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with GNU Emacs. 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* gpr_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; /* match WisiToken.Buffer_Region */
+ result->char_token_start = 1;
+ result->line = 1;
+ result->line_token_start = result->line;
+ result->verbosity = 0;
+ return result;
+}
+
+void
+gpr_free_lexer(wisi_lexer** lexer)
+{
+ free(*lexer);
+ *lexer = 0;
+}
+
+void
+gpr_reset_lexer(wisi_lexer* lexer)
+{
+ lexer->cursor = lexer->buffer;
+ lexer->char_pos = 1;
+ lexer->line = 1;
+}
+
+void
+gpr_set_verbosity
+ (wisi_lexer* lexer, int verbosity)
+{
+ lexer->verbosity = verbosity;
+}
+
+void
+gpr_set_position
+ (wisi_lexer* lexer, size_t byte_position, size_t char_position, int line)
+{
+ lexer->cursor = lexer->buffer + byte_position - 1;
+ lexer->char_pos = char_position;
+ lexer->line = line;
+}
+
+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
+
+static void skip(wisi_lexer* lexer)
+{
+ if (lexer->cursor <= lexer->buffer_last)
+ {
+ ++lexer->cursor;
+ if (lexer->cursor <= lexer->buffer_last)
+ {
+ /* UFT-8 encoding: https://en.wikipedia.org/wiki/UTF-8#Description */
+ if (*lexer->cursor == 0x0A && lexer->cursor > lexer->buffer &&
*(lexer->cursor - 1) == 0x0D)
+ {/* second byte of DOS line ending */
+ }
+ else if ((*lexer->cursor & 0x80) == 0x80 && (*lexer->cursor & 0xC0)
!= 0xC0)
+ {/* byte 2, 3 or 4 of multi-byte UTF-8 char */
+ }
+ else
+ lexer->char_pos++;
+ } else
+ lexer->char_pos++;
+ }
+}
+#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
+
+int gpr_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* line_length)
+{
+ int status = NO_ERROR;
+ *id = -1;
+ if (lexer->cursor > lexer->buffer_last)
+ {
+ *id = 41;
+ *byte_position = lexer->buffer_last - lexer->buffer + 2;
+ *byte_length = 0;
+ *char_position = lexer->char_pos;
+ *char_length = 0;
+ *line_start = lexer->line;
+ *line_length = 0;
+ return status;
+ }
+
+ lexer->byte_token_start = lexer->cursor;
+ lexer->char_token_start = lexer->char_pos;
+ lexer->line_token_start = lexer->line;
+
+ while (*id == -1 && status == 0)
+ {
+
+#line 170 "../gpr_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 yy13;
+ case '\'': goto yy15;
+ case '(': goto yy17;
+ case ')': goto yy19;
+ case ',': goto yy21;
+ case '-': goto yy23;
+ case '.': goto yy24;
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9': goto yy26;
+ case ':': goto yy29;
+ case ';': goto yy31;
+ case '=': goto yy33;
+ case 'A':
+ case 'a': goto yy34;
+ case 'B':
+ case 'D':
+ case 'G':
+ case 'H':
+ case 'J':
+ case 'K':
+ case 'M':
+ case 'Q':
+ case 'V':
+ case 'X':
+ case 'Y':
+ case 'Z':
+ case 'b':
+ case 'd':
+ case 'g':
+ case 'h':
+ case 'j':
+ case 'k':
+ case 'm':
+ case 'q':
+ case 'v':
+ case 'x':
+ case 'y':
+ case 'z': goto yy36;
+ case 'C':
+ case 'c': goto yy38;
+ case 'E':
+ case 'e': goto yy39;
+ case 'F':
+ case 'f': goto yy40;
+ case 'I':
+ case 'i': goto yy41;
+ case 'L':
+ case 'l': goto yy42;
+ case 'N':
+ case 'n': goto yy43;
+ case 'O':
+ case 'o': goto yy44;
+ case 'P':
+ case 'p': goto yy45;
+ case 'R':
+ case 'r': goto yy46;
+ case 'S':
+ case 's': goto yy47;
+ case 'T':
+ case 't': goto yy48;
+ case 'U':
+ case 'u': goto yy49;
+ case 'W':
+ case 'w': goto yy50;
+ case '{': goto yy51;
+ case '|': goto yy52;
+ 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 yy54;
+ case 0xE0: goto yy55;
+ 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 yy56;
+ case 0xF0: goto yy57;
+ case 0xF1:
+ case 0xF2:
+ case 0xF3: goto yy58;
+ case 0xF4: goto yy59;
+ default: goto yy2;
+ }
+yy2:
+ YYDEBUG(2, YYPEEK());
+ YYSKIP();
+yy3:
+ YYDEBUG(3, YYPEEK());
+#line 260 "../gpr.re2c"
+ {status = ERROR_unrecognized_character; continue;}
+#line 318 "../gpr_re2c.c"
+yy4:
+ YYDEBUG(4, YYPEEK());
+ YYSKIP();
+ YYDEBUG(5, YYPEEK());
+#line 258 "../gpr.re2c"
+ {*id = 41; continue;}
+#line 325 "../gpr_re2c.c"
+yy6:
+ YYDEBUG(6, YYPEEK());
+ YYSKIP();
+ YYDEBUG(7, YYPEEK());
+#line 214 "../gpr.re2c"
+ { lexer->byte_token_start = lexer->cursor;
+ lexer->char_token_start = lexer->char_pos;
+ lexer->line_token_start = lexer->line;
+ continue; }
+#line 335 "../gpr_re2c.c"
+yy8:
+ YYDEBUG(8, YYPEEK());
+ YYSKIP();
+ YYDEBUG(9, YYPEEK());
+#line 218 "../gpr.re2c"
+ {*id = 1; lexer->line++; continue;}
+#line 342 "../gpr_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 yy61;
+ default: goto yy3;
+ }
+yy12:
+ YYDEBUG(12, YYPEEK());
+ yyaccept = 0;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'e': goto yy71;
+ case 'i': goto yy72;
+ default: goto yy3;
+ }
+yy13:
+ YYDEBUG(13, YYPEEK());
+ YYSKIP();
+ YYDEBUG(14, YYPEEK());
+#line 246 "../gpr.re2c"
+ {*id = 29; continue;}
+#line 524 "../gpr_re2c.c"
+yy15:
+ YYDEBUG(15, YYPEEK());
+ YYSKIP();
+ YYDEBUG(16, YYPEEK());
+#line 252 "../gpr.re2c"
+ {*id = 35; continue;}
+#line 531 "../gpr_re2c.c"
+yy17:
+ YYDEBUG(17, YYPEEK());
+ YYSKIP();
+ YYDEBUG(18, YYPEEK());
+#line 233 "../gpr.re2c"
+ {*id = 16; continue;}
+#line 538 "../gpr_re2c.c"
+yy19:
+ YYDEBUG(19, YYPEEK());
+ YYSKIP();
+ YYDEBUG(20, YYPEEK());
+#line 240 "../gpr.re2c"
+ {*id = 23; continue;}
+#line 545 "../gpr_re2c.c"
+yy21:
+ YYDEBUG(21, YYPEEK());
+ YYSKIP();
+ YYDEBUG(22, YYPEEK());
+#line 249 "../gpr.re2c"
+ {*id = 32; continue;}
+#line 552 "../gpr_re2c.c"
+yy23:
+ YYDEBUG(23, YYPEEK());
+ yyaccept = 0;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case '-': goto yy73;
+ default: goto yy3;
+ }
+yy24:
+ YYDEBUG(24, YYPEEK());
+ YYSKIP();
+ YYDEBUG(25, YYPEEK());
+#line 250 "../gpr.re2c"
+ {*id = 33; continue;}
+#line 569 "../gpr_re2c.c"
+yy26:
+ YYDEBUG(26, YYPEEK());
+ YYSKIP();
+ yych = YYPEEK();
+ YYDEBUG(27, YYPEEK());
+ switch (yych) {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9': goto yy26;
+ default: goto yy28;
+ }
+yy28:
+ YYDEBUG(28, YYPEEK());
+#line 255 "../gpr.re2c"
+ {*id = 38; continue;}
+#line 592 "../gpr_re2c.c"
+yy29:
+ YYDEBUG(29, YYPEEK());
+ YYSKIP();
+ yych = YYPEEK();
+ switch (yych) {
+ case '=': goto yy75;
+ default: goto yy30;
+ }
+yy30:
+ YYDEBUG(30, YYPEEK());
+#line 247 "../gpr.re2c"
+ {*id = 30; continue;}
+#line 605 "../gpr_re2c.c"
+yy31:
+ YYDEBUG(31, YYPEEK());
+ YYSKIP();
+ YYDEBUG(32, YYPEEK());
+#line 253 "../gpr.re2c"
+ {*id = 36; continue;}
+#line 612 "../gpr_re2c.c"
+yy33:
+ YYDEBUG(33, YYPEEK());
+ YYSKIP();
+ yych = YYPEEK();
+ switch (yych) {
+ case '>': goto yy77;
+ default: goto yy3;
+ }
+yy34:
+ YYDEBUG(34, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'B':
+ case 'b': goto yy79;
+ case 'G':
+ case 'g': goto yy80;
+ case 'T':
+ case 't': goto yy81;
+ default: goto yy37;
+ }
+yy35:
+ YYDEBUG(35, YYPEEK());
+#line 256 "../gpr.re2c"
+ {*id = 39; continue;}
+#line 640 "../gpr_re2c.c"
+yy36:
+ YYDEBUG(36, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+yy37:
+ YYDEBUG(37, YYPEEK());
+ switch (yych) {
+ 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 yy36;
+ 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 yy83;
+ case 0xE0: goto yy84;
+ 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 yy85;
+ case 0xF0: goto yy86;
+ case 0xF1:
+ case 0xF2:
+ case 0xF3: goto yy87;
+ case 0xF4: goto yy88;
+ default: goto yy35;
+ }
+yy38:
+ YYDEBUG(38, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'A':
+ case 'a': goto yy89;
+ case 'O':
+ case 'o': goto yy90;
+ default: goto yy37;
+ }
+yy39:
+ YYDEBUG(39, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'N':
+ case 'n': goto yy91;
+ case 'X':
+ case 'x': goto yy92;
+ default: goto yy37;
+ }
+yy40:
+ YYDEBUG(40, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'O':
+ case 'o': goto yy93;
+ default: goto yy37;
+ }
+yy41:
+ YYDEBUG(41, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'S':
+ case 's': goto yy94;
+ default: goto yy37;
+ }
+yy42:
+ YYDEBUG(42, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'I':
+ case 'i': goto yy96;
+ default: goto yy37;
+ }
+yy43:
+ YYDEBUG(43, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'U':
+ case 'u': goto yy97;
+ default: goto yy37;
+ }
+yy44:
+ YYDEBUG(44, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'T':
+ case 't': goto yy98;
+ default: goto yy37;
+ }
+yy45:
+ YYDEBUG(45, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'A':
+ case 'a': goto yy99;
+ case 'R':
+ case 'r': goto yy100;
+ default: goto yy37;
+ }
+yy46:
+ YYDEBUG(46, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'E':
+ case 'e': goto yy101;
+ default: goto yy37;
+ }
+yy47:
+ YYDEBUG(47, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'T':
+ case 't': goto yy102;
+ default: goto yy37;
+ }
+yy48:
+ YYDEBUG(48, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'Y':
+ case 'y': goto yy103;
+ default: goto yy37;
+ }
+yy49:
+ YYDEBUG(49, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'S':
+ case 's': goto yy104;
+ default: goto yy37;
+ }
+yy50:
+ YYDEBUG(50, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'H':
+ case 'h': goto yy105;
+ case 'I':
+ case 'i': goto yy106;
+ default: goto yy37;
+ }
+yy51:
+ YYDEBUG(51, YYPEEK());
+ yyaccept = 0;
+ YYSKIP();
+ YYBACKUP();
+ yych = 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:
+ 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 yy108;
+ default: goto yy3;
+ }
+yy52:
+ YYDEBUG(52, YYPEEK());
+ YYSKIP();
+ YYDEBUG(53, YYPEEK());
+#line 254 "../gpr.re2c"
+ {*id = 37; continue;}
+#line 1109 "../gpr_re2c.c"
+yy54:
+ YYDEBUG(54, 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 yy36;
+ default: goto yy3;
+ }
+yy55:
+ YYDEBUG(55, 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 yy83;
+ default: goto yy3;
+ }
+yy56:
+ YYDEBUG(56, 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 yy83;
+ default: goto yy3;
+ }
+yy57:
+ YYDEBUG(57, 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 yy85;
+ default: goto yy3;
+ }
+yy58:
+ YYDEBUG(58, 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 yy85;
+ default: goto yy3;
+ }
+yy59:
+ YYDEBUG(59, 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 yy85;
+ default: goto yy3;
+ }
+yy60:
+ YYDEBUG(60, YYPEEK());
+ YYSKIP();
+ yych = YYPEEK();
+yy61:
+ YYDEBUG(61, 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 yy60;
+ case '"': goto yy63;
+ 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 yy65;
+ case 0xE0: goto yy66;
+ 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 yy67;
+ case 0xF0: goto yy68;
+ case 0xF1:
+ case 0xF2:
+ case 0xF3: goto yy69;
+ case 0xF4: goto yy70;
+ default: goto yy62;
+ }
+yy62:
+ YYDEBUG(62, YYPEEK());
+ YYRESTORE();
+ switch (yyaccept) {
+ case 0:
+ goto yy3;
+ case 1:
+ goto yy35;
+ case 2:
+ goto yy64;
+ case 3:
+ goto yy82;
+ case 4:
+ goto yy95;
+ case 5:
+ goto yy134;
+ case 6:
+ goto yy137;
+ case 7:
+ goto yy147;
+ case 8:
+ goto yy162;
+ case 9:
+ goto yy167;
+ case 10:
+ goto yy174;
+ case 11:
+ goto yy176;
+ case 12:
+ goto yy178;
+ case 13:
+ goto yy197;
+ case 14:
+ goto yy206;
+ case 15:
+ goto yy209;
+ case 16:
+ goto yy211;
+ case 17:
+ goto yy213;
+ case 18:
+ goto yy215;
+ case 19:
+ goto yy218;
+ case 20:
+ goto yy222;
+ case 21:
+ goto yy224;
+ case 22:
+ goto yy226;
+ case 23:
+ goto yy236;
+ default:
+ goto yy241;
+ }
+yy63:
+ YYDEBUG(63, YYPEEK());
+ yyaccept = 2;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case '"': goto yy60;
+ default: goto yy64;
+ }
+yy64:
+ YYDEBUG(64, YYPEEK());
+#line 257 "../gpr.re2c"
+ {*id = 40; continue;}
+#line 1675 "../gpr_re2c.c"
+yy65:
+ YYDEBUG(65, 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 yy60;
+ default: goto yy62;
+ }
+yy66:
+ YYDEBUG(66, 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 yy65;
+ default: goto yy62;
+ }
+yy67:
+ YYDEBUG(67, 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 yy65;
+ default: goto yy62;
+ }
+yy68:
+ YYDEBUG(68, 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 yy67;
+ default: goto yy62;
+ }
+yy69:
+ YYDEBUG(69, 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 yy67;
+ default: goto yy62;
+ }
+yy70:
+ YYDEBUG(70, 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 yy67;
+ default: goto yy62;
+ }
+yy71:
+ YYDEBUG(71, YYPEEK());
+ YYSKIP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'l': goto yy117;
+ case 'n': goto yy118;
+ default: goto yy62;
+ }
+yy72:
+ YYDEBUG(72, YYPEEK());
+ YYSKIP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'f': goto yy119;
+ default: goto yy62;
+ }
+yy73:
+ YYDEBUG(73, YYPEEK());
+ YYSKIP();
+ yych = YYPEEK();
+ YYDEBUG(74, 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 yy73;
+ case 0x04:
+ case '\n': goto yy121;
+ 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 yy123;
+ case 0xE0: goto yy124;
+ 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 yy125;
+ case 0xF0: goto yy126;
+ case 0xF1:
+ case 0xF2:
+ case 0xF3: goto yy127;
+ case 0xF4: goto yy128;
+ default: goto yy62;
+ }
+yy75:
+ YYDEBUG(75, YYPEEK());
+ YYSKIP();
+ YYDEBUG(76, YYPEEK());
+#line 248 "../gpr.re2c"
+ {*id = 31; continue;}
+#line 2216 "../gpr_re2c.c"
+yy77:
+ YYDEBUG(77, YYPEEK());
+ YYSKIP();
+ YYDEBUG(78, YYPEEK());
+#line 251 "../gpr.re2c"
+ {*id = 34; continue;}
+#line 2223 "../gpr_re2c.c"
+yy79:
+ YYDEBUG(79, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'S':
+ case 's': goto yy129;
+ default: goto yy37;
+ }
+yy80:
+ YYDEBUG(80, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'G':
+ case 'g': goto yy130;
+ default: goto yy37;
+ }
+yy81:
+ YYDEBUG(81, YYPEEK());
+ yyaccept = 3;
+ YYSKIP();
+ YYBACKUP();
+ 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 '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 yy37;
+ default: goto yy82;
+ }
+yy82:
+ YYDEBUG(82, YYPEEK());
+#line 223 "../gpr.re2c"
+ {*id = 6; continue;}
+#line 2373 "../gpr_re2c.c"
+yy83:
+ YYDEBUG(83, 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 yy36;
+ default: goto yy62;
+ }
+yy84:
+ YYDEBUG(84, 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 yy83;
+ default: goto yy62;
+ }
+yy85:
+ YYDEBUG(85, 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 yy83;
+ default: goto yy62;
+ }
+yy86:
+ YYDEBUG(86, 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 yy85;
+ default: goto yy62;
+ }
+yy87:
+ YYDEBUG(87, 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 yy85;
+ default: goto yy62;
+ }
+yy88:
+ YYDEBUG(88, 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 yy85;
+ default: goto yy62;
+ }
+yy89:
+ YYDEBUG(89, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'S':
+ case 's': goto yy131;
+ default: goto yy37;
+ }
+yy90:
+ YYDEBUG(90, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'N':
+ case 'n': goto yy132;
+ default: goto yy37;
+ }
+yy91:
+ YYDEBUG(91, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'D':
+ case 'd': goto yy133;
+ default: goto yy37;
+ }
+yy92:
+ YYDEBUG(92, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'T':
+ case 't': goto yy135;
+ default: goto yy37;
+ }
+yy93:
+ YYDEBUG(93, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'R':
+ case 'r': goto yy136;
+ default: goto yy37;
+ }
+yy94:
+ YYDEBUG(94, YYPEEK());
+ yyaccept = 4;
+ YYSKIP();
+ YYBACKUP();
+ 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 '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 yy37;
+ default: goto yy95;
+ }
+yy95:
+ YYDEBUG(95, YYPEEK());
+#line 232 "../gpr.re2c"
+ {*id = 15; continue;}
+#line 2886 "../gpr_re2c.c"
+yy96:
+ YYDEBUG(96, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'B':
+ case 'b': goto yy138;
+ default: goto yy37;
+ }
+yy97:
+ YYDEBUG(97, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'L':
+ case 'l': goto yy139;
+ default: goto yy37;
+ }
+yy98:
+ YYDEBUG(98, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'H':
+ case 'h': goto yy140;
+ default: goto yy37;
+ }
+yy99:
+ YYDEBUG(99, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'C':
+ case 'c': goto yy141;
+ default: goto yy37;
+ }
+yy100:
+ YYDEBUG(100, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'O':
+ case 'o': goto yy142;
+ default: goto yy37;
+ }
+yy101:
+ YYDEBUG(101, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'N':
+ case 'n': goto yy143;
+ default: goto yy37;
+ }
+yy102:
+ YYDEBUG(102, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'A':
+ case 'a': goto yy144;
+ default: goto yy37;
+ }
+yy103:
+ YYDEBUG(103, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'P':
+ case 'p': goto yy145;
+ default: goto yy37;
+ }
+yy104:
+ YYDEBUG(104, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'E':
+ case 'e': goto yy146;
+ default: goto yy37;
+ }
+yy105:
+ YYDEBUG(105, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'E':
+ case 'e': goto yy148;
+ default: goto yy37;
+ }
+yy106:
+ YYDEBUG(106, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'T':
+ case 't': goto yy149;
+ default: goto yy37;
+ }
+yy107:
+ YYDEBUG(107, YYPEEK());
+ YYSKIP();
+ yych = YYPEEK();
+yy108:
+ YYDEBUG(108, 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 0x7F: goto yy107;
+ case '}': goto yy109;
+ 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 yy111;
+ case 0xE0: goto yy112;
+ 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 yy113;
+ case 0xF0: goto yy114;
+ case 0xF1:
+ case 0xF2:
+ case 0xF3: goto yy115;
+ case 0xF4: goto yy116;
+ default: goto yy62;
+ }
+yy109:
+ YYDEBUG(109, YYPEEK());
+ YYSKIP();
+ YYDEBUG(110, YYPEEK());
+#line 221 "../gpr.re2c"
+ {*id = 4; if (lexer->cursor[-1] == 0x0a || (lexer->cursor[-1] == 0x0d
&& lexer->cursor[-2] == 0x0a)) lexer->line++; continue;}
+#line 3200 "../gpr_re2c.c"
+yy111:
+ YYDEBUG(111, 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 yy107;
+ default: goto yy62;
+ }
+yy112:
+ YYDEBUG(112, 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 yy111;
+ default: goto yy62;
+ }
+yy113:
+ YYDEBUG(113, 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 yy111;
+ default: goto yy62;
+ }
+yy114:
+ YYDEBUG(114, 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 yy113;
+ default: goto yy62;
+ }
+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 yy113;
+ default: goto yy62;
+ }
+yy116:
+ YYDEBUG(116, 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 yy113;
+ default: goto yy62;
+ }
+yy117:
+ YYDEBUG(117, YYPEEK());
+ YYSKIP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 's': goto yy150;
+ default: goto yy62;
+ }
+yy118:
+ YYDEBUG(118, YYPEEK());
+ YYSKIP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'd': goto yy119;
+ default: goto yy62;
+ }
+yy119:
+ YYDEBUG(119, YYPEEK());
+ YYSKIP();
+ yych = YYPEEK();
+ YYDEBUG(120, 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 yy119;
+ case 0x04:
+ case '\n': goto yy151;
+ 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 yy153;
+ case 0xE0: goto yy154;
+ 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 yy155;
+ case 0xF0: goto yy156;
+ case 0xF1:
+ case 0xF2:
+ case 0xF3: goto yy157;
+ case 0xF4: goto yy158;
+ default: goto yy62;
+ }
+yy121:
+ YYDEBUG(121, YYPEEK());
+ YYSKIP();
+ YYDEBUG(122, YYPEEK());
+#line 219 "../gpr.re2c"
+ {*id = 2; if (lexer->cursor[-1] == 0x0a || (lexer->cursor[-1] == 0x0d
&& lexer->cursor[-2] == 0x0a)) lexer->line++; continue;}
+#line 3740 "../gpr_re2c.c"
+yy123:
+ YYDEBUG(123, 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 yy73;
+ default: goto yy62;
+ }
+yy124:
+ YYDEBUG(124, 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 yy123;
+ default: goto yy62;
+ }
+yy125:
+ YYDEBUG(125, 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 yy123;
+ default: goto yy62;
+ }
+yy126:
+ YYDEBUG(126, 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 yy125;
+ default: goto yy62;
+ }
+yy127:
+ YYDEBUG(127, 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 yy125;
+ default: goto yy62;
+ }
+yy128:
+ YYDEBUG(128, 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 yy125;
+ default: goto yy62;
+ }
+yy129:
+ YYDEBUG(129, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'T':
+ case 't': goto yy159;
+ default: goto yy37;
+ }
+yy130:
+ YYDEBUG(130, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'R':
+ case 'r': goto yy160;
+ default: goto yy37;
+ }
+yy131:
+ YYDEBUG(131, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'E':
+ case 'e': goto yy161;
+ default: goto yy37;
+ }
+yy132:
+ YYDEBUG(132, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'F':
+ case 'f': goto yy163;
+ default: goto yy37;
+ }
+yy133:
+ YYDEBUG(133, YYPEEK());
+ yyaccept = 5;
+ YYSKIP();
+ YYBACKUP();
+ 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 '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 yy37;
+ default: goto yy134;
+ }
+yy134:
+ YYDEBUG(134, YYPEEK());
+#line 227 "../gpr.re2c"
+ {*id = 10; continue;}
+#line 4242 "../gpr_re2c.c"
+yy135:
+ YYDEBUG(135, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'E':
+ case 'e': goto yy164;
+ default: goto yy37;
+ }
+yy136:
+ YYDEBUG(136, YYPEEK());
+ yyaccept = 6;
+ YYSKIP();
+ YYBACKUP();
+ 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 '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 yy37;
+ default: goto yy137;
+ }
+yy137:
+ YYDEBUG(137, YYPEEK());
+#line 231 "../gpr.re2c"
+ {*id = 14; continue;}
+#line 4381 "../gpr_re2c.c"
+yy138:
+ YYDEBUG(138, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'R':
+ case 'r': goto yy165;
+ default: goto yy37;
+ }
+yy139:
+ YYDEBUG(139, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'L':
+ case 'l': goto yy166;
+ default: goto yy37;
+ }
+yy140:
+ YYDEBUG(140, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'E':
+ case 'e': goto yy168;
+ default: goto yy37;
+ }
+yy141:
+ YYDEBUG(141, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'K':
+ case 'k': goto yy169;
+ default: goto yy37;
+ }
+yy142:
+ YYDEBUG(142, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'J':
+ case 'j': goto yy170;
+ default: goto yy37;
+ }
+yy143:
+ YYDEBUG(143, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'A':
+ case 'a': goto yy171;
+ default: goto yy37;
+ }
+yy144:
+ YYDEBUG(144, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'N':
+ case 'n': goto yy172;
+ default: goto yy37;
+ }
+yy145:
+ YYDEBUG(145, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'E':
+ case 'e': goto yy173;
+ default: goto yy37;
+ }
+yy146:
+ YYDEBUG(146, YYPEEK());
+ yyaccept = 7;
+ YYSKIP();
+ YYBACKUP();
+ 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 '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 yy37;
+ default: goto yy147;
+ }
+yy147:
+ YYDEBUG(147, YYPEEK());
+#line 243 "../gpr.re2c"
+ {*id = 26; continue;}
+#line 4597 "../gpr_re2c.c"
+yy148:
+ YYDEBUG(148, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'N':
+ case 'n': goto yy175;
+ default: goto yy37;
+ }
+yy149:
+ YYDEBUG(149, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'H':
+ case 'h': goto yy177;
+ default: goto yy37;
+ }
+yy150:
+ YYDEBUG(150, YYPEEK());
+ YYSKIP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'e': goto yy119;
+ case 'i': goto yy72;
+ default: goto yy62;
+ }
+yy151:
+ YYDEBUG(151, YYPEEK());
+ YYSKIP();
+ YYDEBUG(152, YYPEEK());
+#line 220 "../gpr.re2c"
+ {*id = 3; if (lexer->cursor[-1] == 0x0a || (lexer->cursor[-1] == 0x0d
&& lexer->cursor[-2] == 0x0a)) lexer->line++; continue;}
+#line 4635 "../gpr_re2c.c"
+yy153:
+ YYDEBUG(153, 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 yy119;
+ default: goto yy62;
+ }
+yy154:
+ YYDEBUG(154, 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 yy153;
+ default: goto yy62;
+ }
+yy155:
+ YYDEBUG(155, 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 yy153;
+ default: goto yy62;
+ }
+yy156:
+ YYDEBUG(156, 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 yy155;
+ default: goto yy62;
+ }
+yy157:
+ YYDEBUG(157, 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 yy155;
+ default: goto yy62;
+ }
+yy158:
+ YYDEBUG(158, 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 yy155;
+ default: goto yy62;
+ }
+yy159:
+ YYDEBUG(159, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'R':
+ case 'r': goto yy179;
+ default: goto yy37;
+ }
+yy160:
+ YYDEBUG(160, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'E':
+ case 'e': goto yy180;
+ default: goto yy37;
+ }
+yy161:
+ YYDEBUG(161, YYPEEK());
+ yyaccept = 8;
+ YYSKIP();
+ YYBACKUP();
+ 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 '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 yy37;
+ default: goto yy162;
+ }
+yy162:
+ YYDEBUG(162, YYPEEK());
+#line 225 "../gpr.re2c"
+ {*id = 8; continue;}
+#line 5115 "../gpr_re2c.c"
+yy163:
+ YYDEBUG(163, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'I':
+ case 'i': goto yy181;
+ default: goto yy37;
+ }
+yy164:
+ YYDEBUG(164, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'N':
+ case 'n': goto yy182;
+ case 'R':
+ case 'r': goto yy183;
+ default: goto yy37;
+ }
+yy165:
+ YYDEBUG(165, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'A':
+ case 'a': goto yy184;
+ default: goto yy37;
+ }
+yy166:
+ YYDEBUG(166, YYPEEK());
+ yyaccept = 9;
+ YYSKIP();
+ YYBACKUP();
+ 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 '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 yy37;
+ default: goto yy167;
+ }
+yy167:
+ YYDEBUG(167, YYPEEK());
+#line 235 "../gpr.re2c"
+ {*id = 18; continue;}
+#line 5278 "../gpr_re2c.c"
+yy168:
+ YYDEBUG(168, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'R':
+ case 'r': goto yy185;
+ default: goto yy37;
+ }
+yy169:
+ YYDEBUG(169, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'A':
+ case 'a': goto yy186;
+ default: goto yy37;
+ }
+yy170:
+ YYDEBUG(170, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'E':
+ case 'e': goto yy187;
+ default: goto yy37;
+ }
+yy171:
+ YYDEBUG(171, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'M':
+ case 'm': goto yy188;
+ default: goto yy37;
+ }
+yy172:
+ YYDEBUG(172, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'D':
+ case 'd': goto yy189;
+ default: goto yy37;
+ }
+yy173:
+ YYDEBUG(173, YYPEEK());
+ yyaccept = 10;
+ YYSKIP();
+ YYBACKUP();
+ 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 '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 yy37;
+ default: goto yy174;
+ }
+yy174:
+ YYDEBUG(174, YYPEEK());
+#line 242 "../gpr.re2c"
+ {*id = 25; continue;}
+#line 5461 "../gpr_re2c.c"
+yy175:
+ YYDEBUG(175, YYPEEK());
+ yyaccept = 11;
+ YYSKIP();
+ YYBACKUP();
+ 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 '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 yy37;
+ default: goto yy176;
+ }
+yy176:
+ YYDEBUG(176, YYPEEK());
+#line 244 "../gpr.re2c"
+ {*id = 27; continue;}
+#line 5589 "../gpr_re2c.c"
+yy177:
+ YYDEBUG(177, YYPEEK());
+ yyaccept = 12;
+ YYSKIP();
+ YYBACKUP();
+ 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 '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 yy37;
+ default: goto yy178;
+ }
+yy178:
+ YYDEBUG(178, YYPEEK());
+#line 245 "../gpr.re2c"
+ {*id = 28; continue;}
+#line 5717 "../gpr_re2c.c"
+yy179:
+ YYDEBUG(179, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'A':
+ case 'a': goto yy190;
+ default: goto yy37;
+ }
+yy180:
+ YYDEBUG(180, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'G':
+ case 'g': goto yy191;
+ default: goto yy37;
+ }
+yy181:
+ YYDEBUG(181, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'G':
+ case 'g': goto yy192;
+ default: goto yy37;
+ }
+yy182:
+ YYDEBUG(182, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'D':
+ case 'd': goto yy193;
+ default: goto yy37;
+ }
+yy183:
+ YYDEBUG(183, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'N':
+ case 'n': goto yy194;
+ default: goto yy37;
+ }
+yy184:
+ YYDEBUG(184, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'R':
+ case 'r': goto yy195;
+ default: goto yy37;
+ }
+yy185:
+ YYDEBUG(185, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'S':
+ case 's': goto yy196;
+ default: goto yy37;
+ }
+yy186:
+ YYDEBUG(186, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'G':
+ case 'g': goto yy198;
+ default: goto yy37;
+ }
+yy187:
+ YYDEBUG(187, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'C':
+ case 'c': goto yy199;
+ default: goto yy37;
+ }
+yy188:
+ YYDEBUG(188, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'E':
+ case 'e': goto yy200;
+ default: goto yy37;
+ }
+yy189:
+ YYDEBUG(189, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'A':
+ case 'a': goto yy201;
+ default: goto yy37;
+ }
+yy190:
+ YYDEBUG(190, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'C':
+ case 'c': goto yy202;
+ default: goto yy37;
+ }
+yy191:
+ YYDEBUG(191, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'A':
+ case 'a': goto yy203;
+ default: goto yy37;
+ }
+yy192:
+ YYDEBUG(192, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'U':
+ case 'u': goto yy204;
+ default: goto yy37;
+ }
+yy193:
+ YYDEBUG(193, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'S':
+ case 's': goto yy205;
+ default: goto yy37;
+ }
+yy194:
+ YYDEBUG(194, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'A':
+ case 'a': goto yy207;
+ default: goto yy37;
+ }
+yy195:
+ YYDEBUG(195, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'Y':
+ case 'y': goto yy208;
+ default: goto yy37;
+ }
+yy196:
+ YYDEBUG(196, YYPEEK());
+ yyaccept = 13;
+ YYSKIP();
+ YYBACKUP();
+ 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 '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 yy37;
+ default: goto yy197;
+ }
+yy197:
+ YYDEBUG(197, YYPEEK());
+#line 236 "../gpr.re2c"
+ {*id = 19; continue;}
+#line 6032 "../gpr_re2c.c"
+yy198:
+ YYDEBUG(198, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'E':
+ case 'e': goto yy210;
+ default: goto yy37;
+ }
+yy199:
+ YYDEBUG(199, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'T':
+ case 't': goto yy212;
+ default: goto yy37;
+ }
+yy200:
+ YYDEBUG(200, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'S':
+ case 's': goto yy214;
+ default: goto yy37;
+ }
+yy201:
+ YYDEBUG(201, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'R':
+ case 'r': goto yy216;
+ default: goto yy37;
+ }
+yy202:
+ YYDEBUG(202, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'T':
+ case 't': goto yy217;
+ default: goto yy37;
+ }
+yy203:
+ YYDEBUG(203, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'T':
+ case 't': goto yy219;
+ default: goto yy37;
+ }
+yy204:
+ YYDEBUG(204, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'R':
+ case 'r': goto yy220;
+ default: goto yy37;
+ }
+yy205:
+ YYDEBUG(205, YYPEEK());
+ yyaccept = 14;
+ YYSKIP();
+ YYBACKUP();
+ 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 '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 yy37;
+ default: goto yy206;
+ }
+yy206:
+ YYDEBUG(206, YYPEEK());
+#line 228 "../gpr.re2c"
+ {*id = 11; continue;}
+#line 6237 "../gpr_re2c.c"
+yy207:
+ YYDEBUG(207, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'L':
+ case 'l': goto yy221;
+ default: goto yy37;
+ }
+yy208:
+ YYDEBUG(208, YYPEEK());
+ yyaccept = 15;
+ YYSKIP();
+ YYBACKUP();
+ 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 '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 yy37;
+ default: goto yy209;
+ }
+yy209:
+ YYDEBUG(209, YYPEEK());
+#line 234 "../gpr.re2c"
+ {*id = 17; continue;}
+#line 6376 "../gpr_re2c.c"
+yy210:
+ YYDEBUG(210, YYPEEK());
+ yyaccept = 16;
+ YYSKIP();
+ YYBACKUP();
+ 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 '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 yy37;
+ default: goto yy211;
+ }
+yy211:
+ YYDEBUG(211, YYPEEK());
+#line 237 "../gpr.re2c"
+ {*id = 20; continue;}
+#line 6504 "../gpr_re2c.c"
+yy212:
+ YYDEBUG(212, YYPEEK());
+ yyaccept = 17;
+ YYSKIP();
+ YYBACKUP();
+ 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 '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 yy37;
+ default: goto yy213;
+ }
+yy213:
+ YYDEBUG(213, YYPEEK());
+#line 238 "../gpr.re2c"
+ {*id = 21; continue;}
+#line 6632 "../gpr_re2c.c"
+yy214:
+ YYDEBUG(214, YYPEEK());
+ yyaccept = 18;
+ YYSKIP();
+ YYBACKUP();
+ 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 '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 yy37;
+ default: goto yy215;
+ }
+yy215:
+ YYDEBUG(215, YYPEEK());
+#line 239 "../gpr.re2c"
+ {*id = 22; continue;}
+#line 6760 "../gpr_re2c.c"
+yy216:
+ YYDEBUG(216, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'D':
+ case 'd': goto yy223;
+ default: goto yy37;
+ }
+yy217:
+ YYDEBUG(217, YYPEEK());
+ yyaccept = 19;
+ YYSKIP();
+ YYBACKUP();
+ 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 '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 yy37;
+ default: goto yy218;
+ }
+yy218:
+ YYDEBUG(218, YYPEEK());
+#line 222 "../gpr.re2c"
+ {*id = 5; continue;}
+#line 6899 "../gpr_re2c.c"
+yy219:
+ YYDEBUG(219, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'E':
+ case 'e': goto yy225;
+ default: goto yy37;
+ }
+yy220:
+ YYDEBUG(220, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'A':
+ case 'a': goto yy227;
+ default: goto yy37;
+ }
+yy221:
+ YYDEBUG(221, YYPEEK());
+ yyaccept = 20;
+ YYSKIP();
+ YYBACKUP();
+ 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 '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 '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 yy37;
+ case '_': goto yy228;
+ default: goto yy222;
+ }
+yy222:
+ YYDEBUG(222, YYPEEK());
+#line 229 "../gpr.re2c"
+ {*id = 12; continue;}
+#line 7049 "../gpr_re2c.c"
+yy223:
+ YYDEBUG(223, YYPEEK());
+ yyaccept = 21;
+ YYSKIP();
+ YYBACKUP();
+ 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 '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 yy37;
+ default: goto yy224;
+ }
+yy224:
+ YYDEBUG(224, YYPEEK());
+#line 241 "../gpr.re2c"
+ {*id = 24; continue;}
+#line 7177 "../gpr_re2c.c"
+yy225:
+ YYDEBUG(225, YYPEEK());
+ yyaccept = 22;
+ YYSKIP();
+ YYBACKUP();
+ 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 '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 yy37;
+ default: goto yy226;
+ }
+yy226:
+ YYDEBUG(226, YYPEEK());
+#line 224 "../gpr.re2c"
+ {*id = 7; continue;}
+#line 7305 "../gpr_re2c.c"
+yy227:
+ YYDEBUG(227, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'T':
+ case 't': goto yy229;
+ default: goto yy37;
+ }
+yy228:
+ YYDEBUG(228, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'A':
+ case 'a': goto yy230;
+ default: goto yy37;
+ }
+yy229:
+ YYDEBUG(229, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'I':
+ case 'i': goto yy231;
+ default: goto yy37;
+ }
+yy230:
+ YYDEBUG(230, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'S':
+ case 's': goto yy232;
+ default: goto yy37;
+ }
+yy231:
+ YYDEBUG(231, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'O':
+ case 'o': goto yy233;
+ default: goto yy37;
+ }
+yy232:
+ YYDEBUG(232, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case '_': goto yy234;
+ default: goto yy37;
+ }
+yy233:
+ YYDEBUG(233, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'N':
+ case 'n': goto yy235;
+ default: goto yy37;
+ }
+yy234:
+ YYDEBUG(234, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'L':
+ case 'l': goto yy237;
+ default: goto yy37;
+ }
+yy235:
+ YYDEBUG(235, YYPEEK());
+ yyaccept = 23;
+ YYSKIP();
+ YYBACKUP();
+ 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 '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 yy37;
+ default: goto yy236;
+ }
+yy236:
+ YYDEBUG(236, YYPEEK());
+#line 226 "../gpr.re2c"
+ {*id = 9; continue;}
+#line 7520 "../gpr_re2c.c"
+yy237:
+ YYDEBUG(237, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'I':
+ case 'i': goto yy238;
+ default: goto yy37;
+ }
+yy238:
+ YYDEBUG(238, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'S':
+ case 's': goto yy239;
+ default: goto yy37;
+ }
+yy239:
+ YYDEBUG(239, YYPEEK());
+ yyaccept = 1;
+ YYSKIP();
+ YYBACKUP();
+ yych = YYPEEK();
+ switch (yych) {
+ case 'T':
+ case 't': goto yy240;
+ default: goto yy37;
+ }
+yy240:
+ YYDEBUG(240, YYPEEK());
+ yyaccept = 24;
+ YYSKIP();
+ YYBACKUP();
+ 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 '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 yy37;
+ default: goto yy241;
+ }
+yy241:
+ YYDEBUG(241, YYPEEK());
+#line 230 "../gpr.re2c"
+ {*id = 13; continue;}
+#line 7681 "../gpr_re2c.c"
+}
+#line 261 "../gpr.re2c"
+
+ }
+ /* lexer->cursor and lexer ->char_pos are one char past end of token */
+ *byte_position = lexer->byte_token_start - lexer->buffer + 1;
+ *byte_length = lexer->cursor - lexer->byte_token_start;
+ *char_position = lexer->char_token_start;
+ *char_length = lexer->char_pos - lexer->char_token_start;
+ *line_start = lexer->line_token_start;
+ *line_length = lexer->line - lexer->line_token_start;
+ return status;
+ }
diff --git a/gpr_re2c_c.ads b/gpr_re2c_c.ads
new file mode 100644
index 0000000000..11b6fb962a
--- /dev/null
+++ b/gpr_re2c_c.ads
@@ -0,0 +1,74 @@
+-- generated parser support file. -*- buffer-read-only:t -*-
+-- command line: wisitoken-bnf-generate.exe --generate LR1 Ada_Emacs re2c
PROCESS gpr.wy
+--
+
+-- Copyright (C) 2013 - 2022 Free Software Foundation, Inc.
+
+-- This program is free software; you can redistribute it and/or
+-- modify it under the terms of the GNU General Public License as
+-- published by the Free Software Foundation; either version 3, or (at
+-- your option) any later version.
+--
+-- This software is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of
+-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+-- General Public License for more details.
+--
+-- You should have received a copy of the GNU General Public License
+-- along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
+
+with Interfaces.C;
+with WisiToken;
+with System;
+package gpr_re2c_c is
+
+ function New_Lexer
+ (Buffer : in System.Address;
+ Length : in Interfaces.C.size_t)
+ return System.Address
+ with Import => True,
+ Convention => C,
+ External_Name => "gpr_new_lexer";
+ -- Create the lexer object, passing it the text buffer.
+
+ procedure Free_Lexer (Lexer : in out System.Address)
+ with Import => True,
+ Convention => C,
+ External_Name => "gpr_free_lexer";
+ -- Free the lexer object
+
+ procedure Reset_Lexer (Lexer : in System.Address)
+ with Import => True,
+ Convention => C,
+ External_Name => "gpr_reset_lexer";
+
+ procedure Set_Verbosity
+ (Lexer : in System.Address;
+ Verbosity : in Interfaces.C.int)
+ with Import => True,
+ Convention => C,
+ External_Name => "gpr_set_verbosity";
+ procedure Set_Position
+ (Lexer : in System.Address;
+ Byte_Position : in Interfaces.C.size_t;
+ Char_Position : in Interfaces.C.size_t;
+ Line : in Interfaces.C.int)
+ with Import => True,
+ Convention => C,
+ External_Name => "gpr_set_position";
+
+ 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;
+ Line_Length : out Interfaces.C.int)
+ return Interfaces.C.int
+ with Import => True,
+ Convention => C,
+ External_Name => "gpr_next_token";
+
+end gpr_re2c_c;
diff --git a/install.sh b/install.sh
new file mode 100644
index 0000000000..0f279215ac
--- /dev/null
+++ b/install.sh
@@ -0,0 +1,35 @@
+#!/bin/sh
+# Install executables for Gpr mode.
+#
+# See build.sh for build (must be run before install).
+
+if type alr; then
+ echo "installing gpr-mode executables via Alire"
+
+ if [ x$1 == x ]; then
+ echo "you must specify the install directory with 'install.sh <dir>'"
+ return 1
+ fi
+ # IMPROVEME: when alr supports install, use that
+ cp emacs_gpr_mode*/bin/* $1
+
+elif type gprbuild; then
+ echo "installing gpr-mode executables via gnat compiler"
+
+ # $1 : optional --prefix=<dir>
+ #
+ # If you don't have write permission in the GNAT installation
+ # directory, you need to use --prefix=<dir>, or run with root priviledges.
+
+ if [ -d ../wisi-4.1.? ]; then
+ WISI_DIR=`ls -d ../wisi-4.1.?`
+ fi
+
+ gprinstall -f -p -P gpr_mode_wisi_parse.gpr -aP $WISI_DIR
--install-name=gpr_mode_wisi_parse $1
+
+else
+ echo "neither Alire nor gnat compiler found"
+ return 1
+fi
+
+# end of file.
diff --git a/prj-eglot.el b/prj-eglot.el
new file mode 100644
index 0000000000..a88589f730
--- /dev/null
+++ b/prj-eglot.el
@@ -0,0 +1,40 @@
+;; project settings for building gpr-mode with Alire/editing with eglot -*-
no-byte-compile : t -*-
+
+(require 'ada-mode)
+;; This require is not needed for the following code, but is needed to
+;; ensure ada-mode-hook has sal-ada-mode-setup.
+
+(setq ada-indent-engine 'wisi) ;; ada_language_server 22.0 doesn't support
RangeFormatting
+
+(setq ada-xref-tool 'eglot)
+
+(add-hook 'ada-mode-hook #'ada-eglot-setup)
+
+(let* ((gpr-file (expand-file-name "emacs_gpr_mode.gpr" (file-name-directory
load-file-name)))
+ (prj-file (expand-file-name "prj-eglot.prj" (file-name-directory
load-file-name)))
+ (eglot-workspace-configuration (list `(ada (projectFile . ,gpr-file))))
+
+ (project
+ (create-alire-project
+ :prj-name "gpr-mode main Alire eglot"
+ :prj-file prj-file
+ :gpr-file gpr-file)))
+
+ (wisi-prj-select-cache prj-file nil "Makefile")
+
+ ;; ada_language_server gets GPR_PROJECT_PATH from its process
+ ;; environment, and the gpr file from eglot-workspace-configuration.
+ (let ((process-environment
+ (append
+ (copy-sequence process-environment)
+ (wisi-prj-compile-env project)
+ (wisi-prj-file-env project))))
+
+ (eglot 'ada-mode ;; managed-major-mode
+ project ;; project; project-root is server process directory
+ 'eglot-lsp-server ;; class
+ 'gnat-find-als ;; contact
+ "Ada" ;; language-id
+ ))
+ )
+;; end of file
diff --git a/run_gpr_parse.ads b/run_gpr_parse.ads
new file mode 100644
index 0000000000..86eeb8e8a1
--- /dev/null
+++ b/run_gpr_parse.ads
@@ -0,0 +1,29 @@
+-- Abstract :
+--
+-- Run the gpr parser standalone. Useful for debugging grammar issues.
+--
+-- Copyright (C) 2017 - 2020, 2022 Free Software Foundation, Inc.
+--
+-- This program is free software; you can redistribute it and/or
+-- modify it under terms of the GNU General Public License as
+-- published by the Free Software Foundation; either version 3, or (at
+-- your option) any later version. This program is distributed in the
+-- hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+-- the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+-- PURPOSE. See the GNU General Public License for more details. You
+-- should have received a copy of the GNU General Public License
+-- distributed with this program; see file COPYING. If not, write to
+-- the Free Software Foundation, 51 Franklin Street, Suite 500, Boston,
+-- MA 02110-1335, USA.
+
+pragma License (GPL);
+
+with Gen_Run_Wisi_LR_Parse;
+with Gpr_Process_Main;
+with Wisi.Gpr;
+procedure Run_Gpr_Parse is new Gen_Run_Wisi_LR_Parse
+ (Wisi.Gpr.Parse_Data_Type,
+ null,
+ null,
+ null,
+ Gpr_Process_Main.Create_Parser);
diff --git a/run_gpr_parse.exe b/run_gpr_parse.exe
new file mode 100644
index 0000000000..fc49de5152
Binary files /dev/null and b/run_gpr_parse.exe differ
diff --git a/wisi-gpr.adb b/wisi-gpr.adb
new file mode 100644
index 0000000000..691188a88b
--- /dev/null
+++ b/wisi-gpr.adb
@@ -0,0 +1,84 @@
+-- Abstract :
+--
+-- See spec
+--
+-- Copyright (C) 2017 - 2022 Free Software Foundation, Inc.
+--
+-- This library is free software; you can redistribute it and/or modify it
+-- under terms of the GNU General Public License as published by the Free
+-- 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 Ada.Strings.Fixed;
+with Gpr_Process_Actions;
+package body Wisi.Gpr is
+
+ overriding
+ procedure Initialize (Data : in out Parse_Data_Type)
+ is
+ use all type Gpr_Process_Actions.Token_Enum_ID;
+ begin
+ Data.First_Comment_ID := +COMMENT_ID;
+ Data.Last_Comment_ID := WisiToken.Invalid_Token_ID;
+ Data.Left_Paren_ID := WisiToken.Invalid_Token_ID;
+ Data.Right_Paren_ID := WisiToken.Invalid_Token_ID;
+
+ Data.Statement_IDs.Append (+compilation_unit_ID);
+ Data.Statement_IDs.Append (+with_clause_ID);
+ Data.Statement_IDs.Append (+declarative_item_ID);
+ Data.Statement_IDs.Append (+wisitoken_accept_ID);
+ end Initialize;
+
+ overriding
+ procedure Parse_Language_Params
+ (Data : in out Parse_Data_Type;
+ Params : in String)
+ is
+ pragma Unreferenced (Data);
+ use Ada.Strings.Fixed;
+ First : Integer := Params'First;
+ Last : Integer := Index (Params, " ");
+ begin
+ if Params /= "" then
+ -- must match [1] wisi-parse-format-language-options
+ Gpr_Indent := Integer'Value (Params (First .. Last - 1));
+
+ First := Last + 1;
+ Last := Index (Params, " ", First);
+ Gpr_Indent_Broken := Integer'Value (Params (First .. Last - 1));
+
+ First := Last + 1;
+ Gpr_Indent_When := Integer'Value (Params (First .. Params'Last));
+ end if;
+ end Parse_Language_Params;
+
+ overriding
+ function Get_Token_IDs
+ (User_Data : in Parse_Data_Type;
+ Command_Line : in String;
+ Last : in out Integer)
+ return WisiToken.Token_ID_Arrays.Vector
+ is
+ pragma Unreferenced (User_Data);
+ use Gpr_Process_Actions;
+ begin
+ return IDs : WisiToken.Token_ID_Arrays.Vector do
+ Wisi.Skip (Command_Line, Last, '(');
+ loop
+ IDs.Append (+Token_Enum_ID'Value (Wisi.Get_Enum (Command_Line,
Last)));
+ Wisi.Skip (Command_Line, Last, ' ');
+ exit when Command_Line (Last + 1) = ')';
+ end loop;
+ Last := Last + 1;
+ end return;
+ end Get_Token_IDs;
+
+end Wisi.Gpr;
diff --git a/wisi-gpr.ads b/wisi-gpr.ads
new file mode 100644
index 0000000000..b73d02c581
--- /dev/null
+++ b/wisi-gpr.ads
@@ -0,0 +1,56 @@
+-- Abstract :
+--
+-- Ada implementation of:
+--
+-- [1] gpr-wisi.el
+-- [2] gpr-indent-user-options.el
+--
+-- Copyright (C) 2017 - 2022 Free Software Foundation, Inc.
+--
+-- This library is free software; you can redistribute it and/or modify it
+-- under terms of the GNU General Public License as published by the Free
+-- 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.Gpr is
+
+ Language_Protocol_Version : constant String := "1";
+ -- Defines the data passed to Initialize in Params.
+ --
+ -- This value must match gpr-wisi.el
+ -- gpr-wisi-language-protocol-version.
+
+ -- Indent parameters from [2]
+ Gpr_Indent : Integer := 3;
+ Gpr_Indent_Broken : Integer := 2;
+ Gpr_Indent_When : Integer := 3;
+
+ -- Other parameters
+ End_Names_Optional : Boolean := False;
+
+ type Parse_Data_Type is new Wisi.Parse_Data_Type with null record;
+
+ overriding
+ procedure Initialize (Data : in out Parse_Data_Type);
+
+ overriding
+ procedure Parse_Language_Params
+ (Data : in out Parse_Data_Type;
+ Params : in String);
+
+ overriding
+ function Get_Token_IDs
+ (User_Data : in Parse_Data_Type;
+ Command_Line : in String;
+ Last : in out Integer)
+ return WisiToken.Token_ID_Arrays.Vector;
+
+end Wisi.Gpr;