[antlr3.2] 09/46: * Upstream build now uses Maven * debian/control: - Updated Standards-Version to 3.8.4. - Build-Depends-Indep: add dependencies for Maven build: libantlr-maven-plugin-java, maven-debian-helper, libmaven-site-plugin-java, libstringtemplate-java, libmaven-javadoc-plugin-java - Build-Depends-Indep: add dependencies to build the Javadoc: default-jdk-doc, libmaven-javadoc-plugin-java - antlr3 Depends: remove java1-runtime, add java5-runtime - downgrade antlr3-gcj from Recommands: to Suggests: - create an antlr3-doc package that contains the documentation [TODO] create an antlr3-gunit package and modify maven-debian-helper to deploy the gunit jars to this package * debian/rules: remove include simple-patchsys.mk, replaced by source format 3.0 (quilt) * Add orig-tar to clean up upstream sources * Switch to source format 3.0 (quilt)
Emmanuel Bourg
ebourg-guest at moszumanska.debian.org
Mon Oct 26 20:24:53 UTC 2015
This is an automated email from the git hooks/post-receive script.
ebourg-guest pushed a commit to branch master
in repository antlr3.2.
commit 289d27e70cc2f67fe936decba9364f2b0c8d842d
Author: Ludovic Claude <ludovic.claude at laposte.net>
Date: Sun Jun 20 22:04:22 2010 +0000
* Upstream build now uses Maven
* debian/control:
- Updated Standards-Version to 3.8.4.
- Build-Depends-Indep: add dependencies for Maven build:
libantlr-maven-plugin-java, maven-debian-helper,
libmaven-site-plugin-java, libstringtemplate-java,
libmaven-javadoc-plugin-java
- Build-Depends-Indep: add dependencies to build the Javadoc:
default-jdk-doc, libmaven-javadoc-plugin-java
- antlr3 Depends: remove java1-runtime, add java5-runtime
- downgrade antlr3-gcj from Recommands: to Suggests:
- create an antlr3-doc package that contains the documentation
[TODO] create an antlr3-gunit package and modify maven-debian-helper to deploy the gunit jars to this package
* debian/rules: remove include simple-patchsys.mk, replaced by
source format 3.0 (quilt)
* Add orig-tar to clean up upstream sources
* Switch to source format 3.0 (quilt)
* New upstream version (Closes: #511470).
* debian/watch: Fixed by using site-local absolution download link.
* debian/control: Updated Standards-Version to 3.8.3.
* debian/control: Added Homepage field.
---
debian/README.source | 16 +
debian/antlr3-doc.doc-base.api | 10 +
debian/antlr3-doc.install | 2 +
debian/antlr3.poms | 6 +
debian/changelog | 29 +
debian/compat | 2 +-
debian/control | 36 +-
debian/generated-sources/antlr3/ANTLRv3.tokens | 128 +
debian/generated-sources/antlr3/ANTLRv3Tree.tokens | 128 +
.../generated-sources/antlr3/ActionAnalysis.tokens | 4 +
.../antlr3/ActionTranslator.tokens | 34 +
.../antlr3/org/antlr/grammar/v3/ANTLRv3Lexer.java | 3695 ++++++++
.../antlr3/org/antlr/grammar/v3/ANTLRv3Parser.java | 9447 ++++++++++++++++++++
.../antlr3/org/antlr/grammar/v3/ANTLRv3Tree.java | 3773 ++++++++
.../org/antlr/grammar/v3/ActionAnalysis.java | 425 +
.../org/antlr/grammar/v3/ActionTranslator.java | 3468 +++++++
debian/maven.bootstrap.ignoreRules | 26 +
debian/maven.cleanIgnoreRules | 16 +
debian/maven.ignoreRules | 21 +
debian/maven.properties | 4 +
debian/maven.publishedRules | 18 +
debian/maven.rules | 27 +
debian/orig-tar.sh | 20 +
debian/patches/antlr3-build_xml.patch | 40 -
debian/rules | 53 +-
debian/source/format | 1 +
debian/watch | 3 +-
27 files changed, 21366 insertions(+), 66 deletions(-)
diff --git a/debian/README.source b/debian/README.source
new file mode 100644
index 0000000..dbc0033
--- /dev/null
+++ b/debian/README.source
@@ -0,0 +1,16 @@
+Information about antlr3
+------------------------------
+
+This package was debianized using the mh_make command
+from the maven-debian-helper package.
+
+The build system uses Maven but prevents it from downloading
+anything from the Internet, making the build compliant with
+the Debian policy.
+
+debian/generated-sources contains sources generated with the upstreams
+distribution, using the command:
+
+mvn generate-sources
+mkdir -p debian/generated-sources
+cp -r tool/target/generated-sources/antlr3
diff --git a/debian/antlr3-doc.doc-base.api b/debian/antlr3-doc.doc-base.api
new file mode 100644
index 0000000..c7127c3
--- /dev/null
+++ b/debian/antlr3-doc.doc-base.api
@@ -0,0 +1,10 @@
+Document: antlr3-api
+Title: API Javadoc for ANTLR 3
+Author: ANTLR developers
+Abstract: This is the API Javadoc provided for the
+ antlr3 library.
+Section: Programming
+
+Format: HTML
+Index: /usr/share/doc/antlr3/api/index.html
+Files: /usr/share/doc/antlr3/api/*
diff --git a/debian/antlr3-doc.install b/debian/antlr3-doc.install
new file mode 100644
index 0000000..319171f
--- /dev/null
+++ b/debian/antlr3-doc.install
@@ -0,0 +1,2 @@
+target/site/apidocs/* usr/share/doc/antlr3/api
+
diff --git a/debian/antlr3.poms b/debian/antlr3.poms
new file mode 100644
index 0000000..bdb742d
--- /dev/null
+++ b/debian/antlr3.poms
@@ -0,0 +1,6 @@
+pom.xml
+runtime/Java/pom.xml
+tool/pom.xml
+antlr3-maven-plugin/pom.xml
+gunit/pom.xml
+gunit-maven-plugin/pom.xml
diff --git a/debian/changelog b/debian/changelog
index 4201eac..1b35eb5 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,32 @@
+antlr3 (3.2-1) unstable; urgency=low
+
+ [Ludovic Claude]
+ * Upstream build now uses Maven
+ * debian/control:
+ - Updated Standards-Version to 3.8.4.
+ - Build-Depends-Indep: add dependencies for Maven build:
+ libantlr-maven-plugin-java, maven-debian-helper,
+ libmaven-site-plugin-java, libstringtemplate-java,
+ libmaven-javadoc-plugin-java
+ - Build-Depends-Indep: add dependencies to build the Javadoc:
+ default-jdk-doc, libmaven-javadoc-plugin-java
+ - antlr3 Depends: remove java1-runtime, add java5-runtime
+ - downgrade antlr3-gcj from Recommands: to Suggests:
+ - create an antlr3-doc package that contains the documentation
+ [TODO] create an antlr3-gunit package and modify maven-debian-helper to deploy the gunit jars to this package
+ * debian/rules: remove include simple-patchsys.mk, replaced by
+ source format 3.0 (quilt)
+ * Add orig-tar to clean up upstream sources
+ * Switch to source format 3.0 (quilt)
+
+ [Michael Koch]
+ * New upstream version (Closes: #511470).
+ * debian/watch: Fixed by using site-local absolution download link.
+ * debian/control: Updated Standards-Version to 3.8.3.
+ * debian/control: Added Homepage field.
+
+ -- Ludovic Claude <ludovic.claude at laposte.net> Mon, 04 Jan 2010 23:51:23 +0100
+
antlr3 (3.0.1+dfsg-4) unstable; urgency=low
* Fix build failure for binary-arch only builds. Closes: #502660.
diff --git a/debian/compat b/debian/compat
index 1e8b314..7f8f011 100644
--- a/debian/compat
+++ b/debian/compat
@@ -1 +1 @@
-6
+7
diff --git a/debian/control b/debian/control
index 2e450e2..98e3b9c 100644
--- a/debian/control
+++ b/debian/control
@@ -1,15 +1,23 @@
Source: antlr3
-Section: devel
+Section: java
Priority: optional
Maintainer: Debian Java Maintainers <pkg-java-maintainers at lists.alioth.debian.org>
-Uploaders: Michael Koch <konqueror at gmx.de>
-Build-Depends: debhelper (>= 6), cdbs, default-jdk-builddep, ant-optional, antlr, libstringtemplate-java, junit
-Standards-Version: 3.7.3
+Uploaders: Ludovic Claude <ludovic.claude at laposte.net>, Michael Koch <konqueror at gmx.de>
+Build-Depends: debhelper (>= 7), cdbs, quilt, default-jdk-builddep, maven-debian-helper (>= 1.0), antlr
+Build-Depends-Indep: libantlr-java, libantlr-maven-plugin-java (>= 2.1),
+ libmaven-site-plugin-java (>= 2.0), libstringtemplate-java (>= 3.2.1),
+ libsurefire-java (>= 2.4.3), junit4, libmaven-plugin-testing-java,
+ default-jdk-doc, libmaven-javadoc-plugin-java
+Standards-Version: 3.8.4
+Vcs-Svn: svn://svn.debian.org/svn/pkg-java/trunk/antlr3
+Vcs-Browser: http://svn.debian.org/wsvn/pkg-java/trunk/antlr3
+Homepage: http://www.antlr.org/
Package: antlr3
Architecture: all
-Depends: default-jre-headless | java1-runtime | java2-runtime, libstringtemplate-java
-Recommends: antlr3-gcj
+Depends: ${misc:Depends}, ${maven:Depends}, default-jre-headless | java2-runtime | java5-runtime, libstringtemplate-java
+Recommends: ${maven:OptionalDepends}
+Suggest: antlr3-gcj
Description: language tool for constructing recognizers, compilers etc
ANTLR, ANother Tool for Language Recognition, (formerly PCCTS) is
a language tool that provides a framework for constructing recognizers,
@@ -27,7 +35,7 @@ Description: language tool for constructing recognizers, compilers etc
Package: antlr3-gcj
Architecture: any
-Depends: antlr3 (>= ${Source-Version}), ${misc:Depends}, ${shlibs:Depends}
+Depends: antlr3 (>= ${source:Version}), ${misc:Depends}, ${shlibs:Depends}
Description: language tool for constructing recognizers, compilers etc (native code)
ANTLR, ANother Tool for Language Recognition, (formerly PCCTS) is
a language tool that provides a framework for constructing recognizers,
@@ -35,3 +43,17 @@ Description: language tool for constructing recognizers, compilers etc (native c
or Java actions [You can use PCCTS 1.xx to generate C-based parsers].
.
This package contains the natively compiled code for use by gij.
+
+Package: antlr3-doc
+Architecture: all
+Section: doc
+Depends: ${misc:Depends}, default-jdk-doc
+Suggests: libantlr3-java
+Description: language tool for constructing compilers etc - documentation
+ ANTLR, ANother Tool for Language Recognition, (formerly PCCTS) is
+ a language tool that provides a framework for constructing recognizers,
+ compilers, and translators from grammatical descriptions containing C++
+ or Java actions [You can use PCCTS 1.xx to generate C-based parsers].
+ .
+ This package provides the API documentation for ANTLR 3
+
diff --git a/debian/generated-sources/antlr3/ANTLRv3.tokens b/debian/generated-sources/antlr3/ANTLRv3.tokens
new file mode 100644
index 0000000..f84b628
--- /dev/null
+++ b/debian/generated-sources/antlr3/ANTLRv3.tokens
@@ -0,0 +1,128 @@
+BACKTRACK_SEMPRED=34
+DOUBLE_ANGLE_STRING_LITERAL=53
+LEXER_GRAMMAR=24
+EOA=19
+ARGLIST=22
+SEMPRED=31
+ACTION=47
+EOB=18
+TOKEN_REF=44
+T__93=93
+T__91=91
+RET=23
+T__92=92
+STRING_LITERAL=45
+T__90=90
+ARG=21
+EOR=17
+ARG_ACTION=50
+DOUBLE_QUOTE_STRING_LITERAL=52
+NESTED_ARG_ACTION=60
+ACTION_CHAR_LITERAL=62
+T__80=80
+T__81=81
+RULE=7
+T__82=82
+T__83=83
+ACTION_ESC=64
+PARSER_GRAMMAR=25
+SRC=54
+CHAR_RANGE=14
+INT=49
+EPSILON=15
+T__85=85
+T__84=84
+T__87=87
+T__86=86
+T__89=89
+REWRITE=39
+T__88=88
+WS=66
+T__71=71
+T__72=72
+COMBINED_GRAMMAR=27
+T__70=70
+LEXER=6
+SL_COMMENT=55
+TREE_GRAMMAR=26
+T__76=76
+CLOSURE=10
+T__75=75
+PARSER=5
+T__74=74
+T__73=73
+T__79=79
+T__78=78
+T__77=77
+T__68=68
+T__69=69
+T__67=67
+NESTED_ACTION=63
+ESC=58
+FRAGMENT=35
+ID=20
+TREE_BEGIN=36
+AT=40
+ML_COMMENT=56
+ALT=16
+SCOPE=30
+LABEL_ASSIGN=41
+DOC_COMMENT=4
+WS_LOOP=65
+RANGE=13
+TOKENS=43
+GATED_SEMPRED=32
+LITERAL_CHAR=57
+BANG=38
+LIST_LABEL_ASSIGN=42
+ACTION_STRING_LITERAL=61
+ROOT=37
+RULE_REF=51
+SYNPRED=12
+OPTIONAL=9
+CHAR_LITERAL=46
+LABEL=28
+TEMPLATE=29
+SYN_SEMPRED=33
+XDIGIT=59
+BLOCK=8
+POSITIVE_CLOSURE=11
+OPTIONS=48
+'..'=13
+'!'=38
+'finally'=85
+'|'=82
+'~'=87
+'returns'=23
+'tree'=69
+'lexer'=67
+'throws'=79
+'>'=89
+';'=71
+'grammar'=70
+'='=41
+'@'=40
+'protected'=75
+'::'=73
+'+'=92
+'.'=90
+'=>'=86
+')'=83
+'^'=37
+'parser'=68
+'->'=39
+'$'=93
+'}'=72
+'catch'=84
+'+='=42
+'?'=91
+'^('=36
+'private'=77
+'scope'=30
+'<'=88
+'('=81
+':'=78
+'*'=74
+'fragment'=35
+','=80
+'public'=76
diff --git a/debian/generated-sources/antlr3/ANTLRv3Tree.tokens b/debian/generated-sources/antlr3/ANTLRv3Tree.tokens
new file mode 100644
index 0000000..a13942a
--- /dev/null
+++ b/debian/generated-sources/antlr3/ANTLRv3Tree.tokens
@@ -0,0 +1,128 @@
+BACKTRACK_SEMPRED=34
+DOUBLE_ANGLE_STRING_LITERAL=53
+LEXER_GRAMMAR=24
+EOA=19
+ARGLIST=22
+SEMPRED=31
+ACTION=47
+EOB=18
+TOKEN_REF=44
+T__93=93
+T__91=91
+RET=23
+T__92=92
+STRING_LITERAL=45
+T__90=90
+ARG=21
+EOR=17
+ARG_ACTION=50
+DOUBLE_QUOTE_STRING_LITERAL=52
+NESTED_ARG_ACTION=60
+ACTION_CHAR_LITERAL=62
+T__80=80
+T__81=81
+T__82=82
+RULE=7
+ACTION_ESC=64
+T__83=83
+PARSER_GRAMMAR=25
+SRC=54
+INT=49
+CHAR_RANGE=14
+EPSILON=15
+T__85=85
+T__84=84
+T__87=87
+T__86=86
+REWRITE=39
+T__89=89
+T__88=88
+WS=66
+T__71=71
+T__72=72
+COMBINED_GRAMMAR=27
+T__70=70
+LEXER=6
+SL_COMMENT=55
+TREE_GRAMMAR=26
+T__76=76
+CLOSURE=10
+T__75=75
+PARSER=5
+T__74=74
+T__73=73
+T__79=79
+T__78=78
+T__77=77
+T__68=68
+T__69=69
+T__67=67
+NESTED_ACTION=63
+ESC=58
+FRAGMENT=35
+ID=20
+TREE_BEGIN=36
+AT=40
+ML_COMMENT=56
+ALT=16
+SCOPE=30
+LABEL_ASSIGN=41
+DOC_COMMENT=4
+WS_LOOP=65
+RANGE=13
+TOKENS=43
+GATED_SEMPRED=32
+LITERAL_CHAR=57
+BANG=38
+LIST_LABEL_ASSIGN=42
+ACTION_STRING_LITERAL=61
+ROOT=37
+RULE_REF=51
+SYNPRED=12
+OPTIONAL=9
+CHAR_LITERAL=46
+LABEL=28
+TEMPLATE=29
+SYN_SEMPRED=33
+XDIGIT=59
+BLOCK=8
+POSITIVE_CLOSURE=11
+OPTIONS=48
+'..'=13
+'!'=38
+'|'=82
+'finally'=85
+'~'=87
+'returns'=23
+'tree'=69
+'lexer'=67
+'throws'=79
+'>'=89
+';'=71
+'grammar'=70
+'='=41
+'@'=40
+'protected'=75
+'::'=73
+'+'=92
+'.'=90
+'=>'=86
+')'=83
+'^'=37
+'parser'=68
+'->'=39
+'$'=93
+'}'=72
+'catch'=84
+'+='=42
+'?'=91
+'^('=36
+'private'=77
+'scope'=30
+'<'=88
+':'=78
+'('=81
+'*'=74
+','=80
+'fragment'=35
+'public'=76
diff --git a/debian/generated-sources/antlr3/ActionAnalysis.tokens b/debian/generated-sources/antlr3/ActionAnalysis.tokens
new file mode 100644
index 0000000..2b76807
--- /dev/null
+++ b/debian/generated-sources/antlr3/ActionAnalysis.tokens
@@ -0,0 +1,4 @@
+X_Y=5
+ID=4
+Y=7
+X=6
diff --git a/debian/generated-sources/antlr3/ActionTranslator.tokens b/debian/generated-sources/antlr3/ActionTranslator.tokens
new file mode 100644
index 0000000..7522acf
--- /dev/null
+++ b/debian/generated-sources/antlr3/ActionTranslator.tokens
@@ -0,0 +1,34 @@
+INDIRECT_TEMPLATE_INSTANCE=28
+RULE_SCOPE_ATTR=12
+ESC=32
+SET_RULE_SCOPE_ATTR=11
+DYNAMIC_NEGATIVE_INDEXED_SCOPE_ATTR=22
+SET_ATTRIBUTE=30
+ERROR_SCOPED_XY=20
+INT=37
+TEMPLATE_EXPR=31
+ERROR_XY=33
+LOCAL_ATTR=17
+TEXT=36
+ISOLATED_TOKEN_REF=14
+ID=4
+TOKEN_SCOPE_ATTR=10
+SET_TOKEN_SCOPE_ATTR=9
+ACTION=27
+UNKNOWN_SYNTAX=35
+WS=5
+ARG=25
+TEMPLATE_INSTANCE=26
+ISOLATED_LEXER_RULE_REF=15
+SET_EXPR_ATTRIBUTE=29
+ATTR_VALUE_EXPR=6
+SET_ENCLOSING_RULE_SCOPE_ATTR=7
+SET_LOCAL_ATTR=16
+ENCLOSING_RULE_SCOPE_ATTR=8
+SET_DYNAMIC_SCOPE_ATTR=18
+SCOPE_INDEX_EXPR=21
+ISOLATED_DYNAMIC_SCOPE=24
+LABEL_REF=13
+DYNAMIC_SCOPE_ATTR=19
+ERROR_X=34
+DYNAMIC_ABSOLUTE_INDEXED_SCOPE_ATTR=23
diff --git a/debian/generated-sources/antlr3/org/antlr/grammar/v3/ANTLRv3Lexer.java b/debian/generated-sources/antlr3/org/antlr/grammar/v3/ANTLRv3Lexer.java
new file mode 100644
index 0000000..f57095b
--- /dev/null
+++ b/debian/generated-sources/antlr3/org/antlr/grammar/v3/ANTLRv3Lexer.java
@@ -0,0 +1,3695 @@
+// $ANTLR 3.1.3 Mar 17, 2009 19:23:44 org/antlr/grammar/v3/ANTLRv3.g 2010-05-13 00:10:13
+
+ package org.antlr.grammar.v3;
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+
+public class ANTLRv3Lexer extends Lexer {
+ public static final int BACKTRACK_SEMPRED=34;
+ public static final int DOUBLE_ANGLE_STRING_LITERAL=53;
+ public static final int LEXER_GRAMMAR=24;
+ public static final int EOA=19;
+ public static final int ARGLIST=22;
+ public static final int EOF=-1;
+ public static final int SEMPRED=31;
+ public static final int ACTION=47;
+ public static final int EOB=18;
+ public static final int TOKEN_REF=44;
+ public static final int T__93=93;
+ public static final int T__91=91;
+ public static final int RET=23;
+ public static final int T__92=92;
+ public static final int STRING_LITERAL=45;
+ public static final int T__90=90;
+ public static final int ARG=21;
+ public static final int EOR=17;
+ public static final int ARG_ACTION=50;
+ public static final int DOUBLE_QUOTE_STRING_LITERAL=52;
+ public static final int NESTED_ARG_ACTION=60;
+ public static final int ACTION_CHAR_LITERAL=62;
+ public static final int T__80=80;
+ public static final int T__81=81;
+ public static final int T__82=82;
+ public static final int RULE=7;
+ public static final int ACTION_ESC=64;
+ public static final int T__83=83;
+ public static final int PARSER_GRAMMAR=25;
+ public static final int SRC=54;
+ public static final int INT=49;
+ public static final int CHAR_RANGE=14;
+ public static final int EPSILON=15;
+ public static final int T__85=85;
+ public static final int T__84=84;
+ public static final int T__87=87;
+ public static final int T__86=86;
+ public static final int REWRITE=39;
+ public static final int T__89=89;
+ public static final int T__88=88;
+ public static final int WS=66;
+ public static final int T__71=71;
+ public static final int T__72=72;
+ public static final int COMBINED_GRAMMAR=27;
+ public static final int T__70=70;
+ public static final int LEXER=6;
+ public static final int SL_COMMENT=55;
+ public static final int TREE_GRAMMAR=26;
+ public static final int T__76=76;
+ public static final int CLOSURE=10;
+ public static final int T__75=75;
+ public static final int PARSER=5;
+ public static final int T__74=74;
+ public static final int T__73=73;
+ public static final int T__79=79;
+ public static final int T__78=78;
+ public static final int T__77=77;
+ public static final int T__68=68;
+ public static final int T__69=69;
+ public static final int T__67=67;
+ public static final int NESTED_ACTION=63;
+ public static final int ESC=58;
+ public static final int FRAGMENT=35;
+ public static final int ID=20;
+ public static final int TREE_BEGIN=36;
+ public static final int AT=40;
+ public static final int ML_COMMENT=56;
+ public static final int ALT=16;
+ public static final int SCOPE=30;
+ public static final int LABEL_ASSIGN=41;
+ public static final int DOC_COMMENT=4;
+ public static final int WS_LOOP=65;
+ public static final int RANGE=13;
+ public static final int TOKENS=43;
+ public static final int GATED_SEMPRED=32;
+ public static final int LITERAL_CHAR=57;
+ public static final int BANG=38;
+ public static final int LIST_LABEL_ASSIGN=42;
+ public static final int ACTION_STRING_LITERAL=61;
+ public static final int ROOT=37;
+ public static final int RULE_REF=51;
+ public static final int SYNPRED=12;
+ public static final int OPTIONAL=9;
+ public static final int CHAR_LITERAL=46;
+ public static final int LABEL=28;
+ public static final int TEMPLATE=29;
+ public static final int SYN_SEMPRED=33;
+ public static final int XDIGIT=59;
+ public static final int BLOCK=8;
+ public static final int POSITIVE_CLOSURE=11;
+ public static final int OPTIONS=48;
+
+ // delegates
+ // delegators
+
+ public ANTLRv3Lexer() {;}
+ public ANTLRv3Lexer(CharStream input) {
+ this(input, new RecognizerSharedState());
+ }
+ public ANTLRv3Lexer(CharStream input, RecognizerSharedState state) {
+ super(input,state);
+
+ }
+ public String getGrammarFileName() { return "org/antlr/grammar/v3/ANTLRv3.g"; }
+
+ // $ANTLR start "RET"
+ public final void mRET() throws RecognitionException {
+ try {
+ int _type = RET;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:7:5: ( 'returns' )
+ // org/antlr/grammar/v3/ANTLRv3.g:7:7: 'returns'
+ {
+ match("returns");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RET"
+
+ // $ANTLR start "SCOPE"
+ public final void mSCOPE() throws RecognitionException {
+ try {
+ int _type = SCOPE;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:8:7: ( 'scope' )
+ // org/antlr/grammar/v3/ANTLRv3.g:8:9: 'scope'
+ {
+ match("scope");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "SCOPE"
+
+ // $ANTLR start "FRAGMENT"
+ public final void mFRAGMENT() throws RecognitionException {
+ try {
+ int _type = FRAGMENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:9:10: ( 'fragment' )
+ // org/antlr/grammar/v3/ANTLRv3.g:9:12: 'fragment'
+ {
+ match("fragment");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "FRAGMENT"
+
+ // $ANTLR start "TREE_BEGIN"
+ public final void mTREE_BEGIN() throws RecognitionException {
+ try {
+ int _type = TREE_BEGIN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:10:12: ( '^(' )
+ // org/antlr/grammar/v3/ANTLRv3.g:10:14: '^('
+ {
+ match("^(");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "TREE_BEGIN"
+
+ // $ANTLR start "ROOT"
+ public final void mROOT() throws RecognitionException {
+ try {
+ int _type = ROOT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:11:6: ( '^' )
+ // org/antlr/grammar/v3/ANTLRv3.g:11:8: '^'
+ {
+ match('^');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "ROOT"
+
+ // $ANTLR start "BANG"
+ public final void mBANG() throws RecognitionException {
+ try {
+ int _type = BANG;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:12:6: ( '!' )
+ // org/antlr/grammar/v3/ANTLRv3.g:12:8: '!'
+ {
+ match('!');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "BANG"
+
+ // $ANTLR start "RANGE"
+ public final void mRANGE() throws RecognitionException {
+ try {
+ int _type = RANGE;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:13:7: ( '..' )
+ // org/antlr/grammar/v3/ANTLRv3.g:13:9: '..'
+ {
+ match("..");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RANGE"
+
+ // $ANTLR start "REWRITE"
+ public final void mREWRITE() throws RecognitionException {
+ try {
+ int _type = REWRITE;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:14:9: ( '->' )
+ // org/antlr/grammar/v3/ANTLRv3.g:14:11: '->'
+ {
+ match("->");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "REWRITE"
+
+ // $ANTLR start "AT"
+ public final void mAT() throws RecognitionException {
+ try {
+ int _type = AT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:15:4: ( '@' )
+ // org/antlr/grammar/v3/ANTLRv3.g:15:6: '@'
+ {
+ match('@');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "AT"
+
+ // $ANTLR start "LABEL_ASSIGN"
+ public final void mLABEL_ASSIGN() throws RecognitionException {
+ try {
+ int _type = LABEL_ASSIGN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:16:14: ( '=' )
+ // org/antlr/grammar/v3/ANTLRv3.g:16:16: '='
+ {
+ match('=');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "LABEL_ASSIGN"
+
+ // $ANTLR start "LIST_LABEL_ASSIGN"
+ public final void mLIST_LABEL_ASSIGN() throws RecognitionException {
+ try {
+ int _type = LIST_LABEL_ASSIGN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:17:19: ( '+=' )
+ // org/antlr/grammar/v3/ANTLRv3.g:17:21: '+='
+ {
+ match("+=");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "LIST_LABEL_ASSIGN"
+
+ // $ANTLR start "T__67"
+ public final void mT__67() throws RecognitionException {
+ try {
+ int _type = T__67;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:18:7: ( 'lexer' )
+ // org/antlr/grammar/v3/ANTLRv3.g:18:9: 'lexer'
+ {
+ match("lexer");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__67"
+
+ // $ANTLR start "T__68"
+ public final void mT__68() throws RecognitionException {
+ try {
+ int _type = T__68;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:19:7: ( 'parser' )
+ // org/antlr/grammar/v3/ANTLRv3.g:19:9: 'parser'
+ {
+ match("parser");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__68"
+
+ // $ANTLR start "T__69"
+ public final void mT__69() throws RecognitionException {
+ try {
+ int _type = T__69;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:20:7: ( 'tree' )
+ // org/antlr/grammar/v3/ANTLRv3.g:20:9: 'tree'
+ {
+ match("tree");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__69"
+
+ // $ANTLR start "T__70"
+ public final void mT__70() throws RecognitionException {
+ try {
+ int _type = T__70;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:21:7: ( 'grammar' )
+ // org/antlr/grammar/v3/ANTLRv3.g:21:9: 'grammar'
+ {
+ match("grammar");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__70"
+
+ // $ANTLR start "T__71"
+ public final void mT__71() throws RecognitionException {
+ try {
+ int _type = T__71;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:22:7: ( ';' )
+ // org/antlr/grammar/v3/ANTLRv3.g:22:9: ';'
+ {
+ match(';');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__71"
+
+ // $ANTLR start "T__72"
+ public final void mT__72() throws RecognitionException {
+ try {
+ int _type = T__72;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:23:7: ( '}' )
+ // org/antlr/grammar/v3/ANTLRv3.g:23:9: '}'
+ {
+ match('}');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__72"
+
+ // $ANTLR start "T__73"
+ public final void mT__73() throws RecognitionException {
+ try {
+ int _type = T__73;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:24:7: ( '::' )
+ // org/antlr/grammar/v3/ANTLRv3.g:24:9: '::'
+ {
+ match("::");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__73"
+
+ // $ANTLR start "T__74"
+ public final void mT__74() throws RecognitionException {
+ try {
+ int _type = T__74;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:25:7: ( '*' )
+ // org/antlr/grammar/v3/ANTLRv3.g:25:9: '*'
+ {
+ match('*');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__74"
+
+ // $ANTLR start "T__75"
+ public final void mT__75() throws RecognitionException {
+ try {
+ int _type = T__75;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:26:7: ( 'protected' )
+ // org/antlr/grammar/v3/ANTLRv3.g:26:9: 'protected'
+ {
+ match("protected");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__75"
+
+ // $ANTLR start "T__76"
+ public final void mT__76() throws RecognitionException {
+ try {
+ int _type = T__76;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:27:7: ( 'public' )
+ // org/antlr/grammar/v3/ANTLRv3.g:27:9: 'public'
+ {
+ match("public");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__76"
+
+ // $ANTLR start "T__77"
+ public final void mT__77() throws RecognitionException {
+ try {
+ int _type = T__77;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:28:7: ( 'private' )
+ // org/antlr/grammar/v3/ANTLRv3.g:28:9: 'private'
+ {
+ match("private");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__77"
+
+ // $ANTLR start "T__78"
+ public final void mT__78() throws RecognitionException {
+ try {
+ int _type = T__78;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:29:7: ( ':' )
+ // org/antlr/grammar/v3/ANTLRv3.g:29:9: ':'
+ {
+ match(':');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__78"
+
+ // $ANTLR start "T__79"
+ public final void mT__79() throws RecognitionException {
+ try {
+ int _type = T__79;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:30:7: ( 'throws' )
+ // org/antlr/grammar/v3/ANTLRv3.g:30:9: 'throws'
+ {
+ match("throws");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__79"
+
+ // $ANTLR start "T__80"
+ public final void mT__80() throws RecognitionException {
+ try {
+ int _type = T__80;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:31:7: ( ',' )
+ // org/antlr/grammar/v3/ANTLRv3.g:31:9: ','
+ {
+ match(',');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__80"
+
+ // $ANTLR start "T__81"
+ public final void mT__81() throws RecognitionException {
+ try {
+ int _type = T__81;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:32:7: ( '(' )
+ // org/antlr/grammar/v3/ANTLRv3.g:32:9: '('
+ {
+ match('(');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__81"
+
+ // $ANTLR start "T__82"
+ public final void mT__82() throws RecognitionException {
+ try {
+ int _type = T__82;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:33:7: ( '|' )
+ // org/antlr/grammar/v3/ANTLRv3.g:33:9: '|'
+ {
+ match('|');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__82"
+
+ // $ANTLR start "T__83"
+ public final void mT__83() throws RecognitionException {
+ try {
+ int _type = T__83;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:34:7: ( ')' )
+ // org/antlr/grammar/v3/ANTLRv3.g:34:9: ')'
+ {
+ match(')');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__83"
+
+ // $ANTLR start "T__84"
+ public final void mT__84() throws RecognitionException {
+ try {
+ int _type = T__84;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:35:7: ( 'catch' )
+ // org/antlr/grammar/v3/ANTLRv3.g:35:9: 'catch'
+ {
+ match("catch");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__84"
+
+ // $ANTLR start "T__85"
+ public final void mT__85() throws RecognitionException {
+ try {
+ int _type = T__85;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:36:7: ( 'finally' )
+ // org/antlr/grammar/v3/ANTLRv3.g:36:9: 'finally'
+ {
+ match("finally");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__85"
+
+ // $ANTLR start "T__86"
+ public final void mT__86() throws RecognitionException {
+ try {
+ int _type = T__86;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:37:7: ( '=>' )
+ // org/antlr/grammar/v3/ANTLRv3.g:37:9: '=>'
+ {
+ match("=>");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__86"
+
+ // $ANTLR start "T__87"
+ public final void mT__87() throws RecognitionException {
+ try {
+ int _type = T__87;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:38:7: ( '~' )
+ // org/antlr/grammar/v3/ANTLRv3.g:38:9: '~'
+ {
+ match('~');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__87"
+
+ // $ANTLR start "T__88"
+ public final void mT__88() throws RecognitionException {
+ try {
+ int _type = T__88;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:39:7: ( '<' )
+ // org/antlr/grammar/v3/ANTLRv3.g:39:9: '<'
+ {
+ match('<');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__88"
+
+ // $ANTLR start "T__89"
+ public final void mT__89() throws RecognitionException {
+ try {
+ int _type = T__89;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:40:7: ( '>' )
+ // org/antlr/grammar/v3/ANTLRv3.g:40:9: '>'
+ {
+ match('>');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__89"
+
+ // $ANTLR start "T__90"
+ public final void mT__90() throws RecognitionException {
+ try {
+ int _type = T__90;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:41:7: ( '.' )
+ // org/antlr/grammar/v3/ANTLRv3.g:41:9: '.'
+ {
+ match('.');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__90"
+
+ // $ANTLR start "T__91"
+ public final void mT__91() throws RecognitionException {
+ try {
+ int _type = T__91;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:42:7: ( '?' )
+ // org/antlr/grammar/v3/ANTLRv3.g:42:9: '?'
+ {
+ match('?');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__91"
+
+ // $ANTLR start "T__92"
+ public final void mT__92() throws RecognitionException {
+ try {
+ int _type = T__92;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:43:7: ( '+' )
+ // org/antlr/grammar/v3/ANTLRv3.g:43:9: '+'
+ {
+ match('+');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__92"
+
+ // $ANTLR start "T__93"
+ public final void mT__93() throws RecognitionException {
+ try {
+ int _type = T__93;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:44:7: ( '$' )
+ // org/antlr/grammar/v3/ANTLRv3.g:44:9: '$'
+ {
+ match('$');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__93"
+
+ // $ANTLR start "SL_COMMENT"
+ public final void mSL_COMMENT() throws RecognitionException {
+ try {
+ int _type = SL_COMMENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:472:3: ( '//' ( ' $ANTLR ' SRC | (~ ( '\\r' | '\\n' ) )* ) ( '\\r' )? '\\n' )
+ // org/antlr/grammar/v3/ANTLRv3.g:472:5: '//' ( ' $ANTLR ' SRC | (~ ( '\\r' | '\\n' ) )* ) ( '\\r' )? '\\n'
+ {
+ match("//");
+
+ // org/antlr/grammar/v3/ANTLRv3.g:473:5: ( ' $ANTLR ' SRC | (~ ( '\\r' | '\\n' ) )* )
+ int alt2=2;
+ alt2 = dfa2.predict(input);
+ switch (alt2) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:473:7: ' $ANTLR ' SRC
+ {
+ match(" $ANTLR ");
+
+ mSRC();
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:474:6: (~ ( '\\r' | '\\n' ) )*
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:474:6: (~ ( '\\r' | '\\n' ) )*
+ loop1:
+ do {
+ int alt1=2;
+ int LA1_0 = input.LA(1);
+
+ if ( ((LA1_0>='\u0000' && LA1_0<='\t')||(LA1_0>='\u000B' && LA1_0<='\f')||(LA1_0>='\u000E' && LA1_0<='\uFFFF')) ) {
+ alt1=1;
+ }
+
+
+ switch (alt1) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:474:6: ~ ( '\\r' | '\\n' )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop1;
+ }
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+ // org/antlr/grammar/v3/ANTLRv3.g:476:3: ( '\\r' )?
+ int alt3=2;
+ int LA3_0 = input.LA(1);
+
+ if ( (LA3_0=='\r') ) {
+ alt3=1;
+ }
+ switch (alt3) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:476:3: '\\r'
+ {
+ match('\r');
+
+ }
+ break;
+
+ }
+
+ match('\n');
+ _channel=HIDDEN;
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "SL_COMMENT"
+
+ // $ANTLR start "ML_COMMENT"
+ public final void mML_COMMENT() throws RecognitionException {
+ try {
+ int _type = ML_COMMENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:481:2: ( '/*' ( . )* '*/' )
+ // org/antlr/grammar/v3/ANTLRv3.g:481:4: '/*' ( . )* '*/'
+ {
+ match("/*");
+
+ if (input.LA(1)=='*') _type=DOC_COMMENT; else _channel=HIDDEN;
+ // org/antlr/grammar/v3/ANTLRv3.g:481:74: ( . )*
+ loop4:
+ do {
+ int alt4=2;
+ int LA4_0 = input.LA(1);
+
+ if ( (LA4_0=='*') ) {
+ int LA4_1 = input.LA(2);
+
+ if ( (LA4_1=='/') ) {
+ alt4=2;
+ }
+ else if ( ((LA4_1>='\u0000' && LA4_1<='.')||(LA4_1>='0' && LA4_1<='\uFFFF')) ) {
+ alt4=1;
+ }
+
+
+ }
+ else if ( ((LA4_0>='\u0000' && LA4_0<=')')||(LA4_0>='+' && LA4_0<='\uFFFF')) ) {
+ alt4=1;
+ }
+
+
+ switch (alt4) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:481:74: .
+ {
+ matchAny();
+
+ }
+ break;
+
+ default :
+ break loop4;
+ }
+ } while (true);
+
+ match("*/");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "ML_COMMENT"
+
+ // $ANTLR start "CHAR_LITERAL"
+ public final void mCHAR_LITERAL() throws RecognitionException {
+ try {
+ int _type = CHAR_LITERAL;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:485:2: ( '\\'' LITERAL_CHAR '\\'' )
+ // org/antlr/grammar/v3/ANTLRv3.g:485:4: '\\'' LITERAL_CHAR '\\''
+ {
+ match('\'');
+ mLITERAL_CHAR();
+ match('\'');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "CHAR_LITERAL"
+
+ // $ANTLR start "STRING_LITERAL"
+ public final void mSTRING_LITERAL() throws RecognitionException {
+ try {
+ int _type = STRING_LITERAL;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:489:2: ( '\\'' LITERAL_CHAR ( LITERAL_CHAR )* '\\'' )
+ // org/antlr/grammar/v3/ANTLRv3.g:489:4: '\\'' LITERAL_CHAR ( LITERAL_CHAR )* '\\''
+ {
+ match('\'');
+ mLITERAL_CHAR();
+ // org/antlr/grammar/v3/ANTLRv3.g:489:22: ( LITERAL_CHAR )*
+ loop5:
+ do {
+ int alt5=2;
+ int LA5_0 = input.LA(1);
+
+ if ( ((LA5_0>='\u0000' && LA5_0<='&')||(LA5_0>='(' && LA5_0<='\uFFFF')) ) {
+ alt5=1;
+ }
+
+
+ switch (alt5) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:489:22: LITERAL_CHAR
+ {
+ mLITERAL_CHAR();
+
+ }
+ break;
+
+ default :
+ break loop5;
+ }
+ } while (true);
+
+ match('\'');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "STRING_LITERAL"
+
+ // $ANTLR start "LITERAL_CHAR"
+ public final void mLITERAL_CHAR() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:494:2: ( ESC | ~ ( '\\'' | '\\\\' ) )
+ int alt6=2;
+ int LA6_0 = input.LA(1);
+
+ if ( (LA6_0=='\\') ) {
+ alt6=1;
+ }
+ else if ( ((LA6_0>='\u0000' && LA6_0<='&')||(LA6_0>='(' && LA6_0<='[')||(LA6_0>=']' && LA6_0<='\uFFFF')) ) {
+ alt6=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 6, 0, input);
+
+ throw nvae;
+ }
+ switch (alt6) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:494:4: ESC
+ {
+ mESC();
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:495:4: ~ ( '\\'' | '\\\\' )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ }
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "LITERAL_CHAR"
+
+ // $ANTLR start "DOUBLE_QUOTE_STRING_LITERAL"
+ public final void mDOUBLE_QUOTE_STRING_LITERAL() throws RecognitionException {
+ try {
+ int _type = DOUBLE_QUOTE_STRING_LITERAL;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:499:2: ( '\"' ( ESC | ~ ( '\\\\' | '\"' ) )* '\"' )
+ // org/antlr/grammar/v3/ANTLRv3.g:499:4: '\"' ( ESC | ~ ( '\\\\' | '\"' ) )* '\"'
+ {
+ match('\"');
+ // org/antlr/grammar/v3/ANTLRv3.g:499:8: ( ESC | ~ ( '\\\\' | '\"' ) )*
+ loop7:
+ do {
+ int alt7=3;
+ int LA7_0 = input.LA(1);
+
+ if ( (LA7_0=='\\') ) {
+ alt7=1;
+ }
+ else if ( ((LA7_0>='\u0000' && LA7_0<='!')||(LA7_0>='#' && LA7_0<='[')||(LA7_0>=']' && LA7_0<='\uFFFF')) ) {
+ alt7=2;
+ }
+
+
+ switch (alt7) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:499:9: ESC
+ {
+ mESC();
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:499:15: ~ ( '\\\\' | '\"' )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop7;
+ }
+ } while (true);
+
+ match('\"');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "DOUBLE_QUOTE_STRING_LITERAL"
+
+ // $ANTLR start "DOUBLE_ANGLE_STRING_LITERAL"
+ public final void mDOUBLE_ANGLE_STRING_LITERAL() throws RecognitionException {
+ try {
+ int _type = DOUBLE_ANGLE_STRING_LITERAL;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:503:2: ( '<<' ( . )* '>>' )
+ // org/antlr/grammar/v3/ANTLRv3.g:503:4: '<<' ( . )* '>>'
+ {
+ match("<<");
+
+ // org/antlr/grammar/v3/ANTLRv3.g:503:9: ( . )*
+ loop8:
+ do {
+ int alt8=2;
+ int LA8_0 = input.LA(1);
+
+ if ( (LA8_0=='>') ) {
+ int LA8_1 = input.LA(2);
+
+ if ( (LA8_1=='>') ) {
+ alt8=2;
+ }
+ else if ( ((LA8_1>='\u0000' && LA8_1<='=')||(LA8_1>='?' && LA8_1<='\uFFFF')) ) {
+ alt8=1;
+ }
+
+
+ }
+ else if ( ((LA8_0>='\u0000' && LA8_0<='=')||(LA8_0>='?' && LA8_0<='\uFFFF')) ) {
+ alt8=1;
+ }
+
+
+ switch (alt8) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:503:9: .
+ {
+ matchAny();
+
+ }
+ break;
+
+ default :
+ break loop8;
+ }
+ } while (true);
+
+ match(">>");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "DOUBLE_ANGLE_STRING_LITERAL"
+
+ // $ANTLR start "ESC"
+ public final void mESC() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:507:5: ( '\\\\' ( 'n' | 'r' | 't' | 'b' | 'f' | '\"' | '\\'' | '\\\\' | '>' | 'u' XDIGIT XDIGIT XDIGIT XDIGIT | . ) )
+ // org/antlr/grammar/v3/ANTLRv3.g:507:7: '\\\\' ( 'n' | 'r' | 't' | 'b' | 'f' | '\"' | '\\'' | '\\\\' | '>' | 'u' XDIGIT XDIGIT XDIGIT XDIGIT | . )
+ {
+ match('\\');
+ // org/antlr/grammar/v3/ANTLRv3.g:508:3: ( 'n' | 'r' | 't' | 'b' | 'f' | '\"' | '\\'' | '\\\\' | '>' | 'u' XDIGIT XDIGIT XDIGIT XDIGIT | . )
+ int alt9=11;
+ alt9 = dfa9.predict(input);
+ switch (alt9) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:508:5: 'n'
+ {
+ match('n');
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:509:5: 'r'
+ {
+ match('r');
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3.g:510:5: 't'
+ {
+ match('t');
+
+ }
+ break;
+ case 4 :
+ // org/antlr/grammar/v3/ANTLRv3.g:511:5: 'b'
+ {
+ match('b');
+
+ }
+ break;
+ case 5 :
+ // org/antlr/grammar/v3/ANTLRv3.g:512:5: 'f'
+ {
+ match('f');
+
+ }
+ break;
+ case 6 :
+ // org/antlr/grammar/v3/ANTLRv3.g:513:5: '\"'
+ {
+ match('\"');
+
+ }
+ break;
+ case 7 :
+ // org/antlr/grammar/v3/ANTLRv3.g:514:5: '\\''
+ {
+ match('\'');
+
+ }
+ break;
+ case 8 :
+ // org/antlr/grammar/v3/ANTLRv3.g:515:5: '\\\\'
+ {
+ match('\\');
+
+ }
+ break;
+ case 9 :
+ // org/antlr/grammar/v3/ANTLRv3.g:516:5: '>'
+ {
+ match('>');
+
+ }
+ break;
+ case 10 :
+ // org/antlr/grammar/v3/ANTLRv3.g:517:5: 'u' XDIGIT XDIGIT XDIGIT XDIGIT
+ {
+ match('u');
+ mXDIGIT();
+ mXDIGIT();
+ mXDIGIT();
+ mXDIGIT();
+
+ }
+ break;
+ case 11 :
+ // org/antlr/grammar/v3/ANTLRv3.g:518:5: .
+ {
+ matchAny();
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "ESC"
+
+ // $ANTLR start "XDIGIT"
+ public final void mXDIGIT() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:523:8: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )
+ // org/antlr/grammar/v3/ANTLRv3.g:
+ {
+ if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||(input.LA(1)>='a' && input.LA(1)<='f') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "XDIGIT"
+
+ // $ANTLR start "INT"
+ public final void mINT() throws RecognitionException {
+ try {
+ int _type = INT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:529:5: ( ( '0' .. '9' )+ )
+ // org/antlr/grammar/v3/ANTLRv3.g:529:7: ( '0' .. '9' )+
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:529:7: ( '0' .. '9' )+
+ int cnt10=0;
+ loop10:
+ do {
+ int alt10=2;
+ int LA10_0 = input.LA(1);
+
+ if ( ((LA10_0>='0' && LA10_0<='9')) ) {
+ alt10=1;
+ }
+
+
+ switch (alt10) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:529:7: '0' .. '9'
+ {
+ matchRange('0','9');
+
+ }
+ break;
+
+ default :
+ if ( cnt10 >= 1 ) break loop10;
+ EarlyExitException eee =
+ new EarlyExitException(10, input);
+ throw eee;
+ }
+ cnt10++;
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "INT"
+
+ // $ANTLR start "ARG_ACTION"
+ public final void mARG_ACTION() throws RecognitionException {
+ try {
+ int _type = ARG_ACTION;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:533:2: ( NESTED_ARG_ACTION )
+ // org/antlr/grammar/v3/ANTLRv3.g:533:4: NESTED_ARG_ACTION
+ {
+ mNESTED_ARG_ACTION();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "ARG_ACTION"
+
+ // $ANTLR start "NESTED_ARG_ACTION"
+ public final void mNESTED_ARG_ACTION() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:537:19: ( '[' ( options {greedy=false; k=1; } : NESTED_ARG_ACTION | ACTION_STRING_LITERAL | ACTION_CHAR_LITERAL | . )* ']' )
+ // org/antlr/grammar/v3/ANTLRv3.g:538:2: '[' ( options {greedy=false; k=1; } : NESTED_ARG_ACTION | ACTION_STRING_LITERAL | ACTION_CHAR_LITERAL | . )* ']'
+ {
+ match('[');
+ // org/antlr/grammar/v3/ANTLRv3.g:539:2: ( options {greedy=false; k=1; } : NESTED_ARG_ACTION | ACTION_STRING_LITERAL | ACTION_CHAR_LITERAL | . )*
+ loop11:
+ do {
+ int alt11=5;
+ int LA11_0 = input.LA(1);
+
+ if ( (LA11_0==']') ) {
+ alt11=5;
+ }
+ else if ( (LA11_0=='[') ) {
+ alt11=1;
+ }
+ else if ( (LA11_0=='\"') ) {
+ alt11=2;
+ }
+ else if ( (LA11_0=='\'') ) {
+ alt11=3;
+ }
+ else if ( ((LA11_0>='\u0000' && LA11_0<='!')||(LA11_0>='#' && LA11_0<='&')||(LA11_0>='(' && LA11_0<='Z')||LA11_0=='\\'||(LA11_0>='^' && LA11_0<='\uFFFF')) ) {
+ alt11=4;
+ }
+
+
+ switch (alt11) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:540:4: NESTED_ARG_ACTION
+ {
+ mNESTED_ARG_ACTION();
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:541:4: ACTION_STRING_LITERAL
+ {
+ mACTION_STRING_LITERAL();
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3.g:542:4: ACTION_CHAR_LITERAL
+ {
+ mACTION_CHAR_LITERAL();
+
+ }
+ break;
+ case 4 :
+ // org/antlr/grammar/v3/ANTLRv3.g:543:4: .
+ {
+ matchAny();
+
+ }
+ break;
+
+ default :
+ break loop11;
+ }
+ } while (true);
+
+ match(']');
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "NESTED_ARG_ACTION"
+
+ // $ANTLR start "ACTION"
+ public final void mACTION() throws RecognitionException {
+ try {
+ int _type = ACTION;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:550:2: ( NESTED_ACTION ( '?' )? )
+ // org/antlr/grammar/v3/ANTLRv3.g:550:4: NESTED_ACTION ( '?' )?
+ {
+ mNESTED_ACTION();
+ // org/antlr/grammar/v3/ANTLRv3.g:550:18: ( '?' )?
+ int alt12=2;
+ int LA12_0 = input.LA(1);
+
+ if ( (LA12_0=='?') ) {
+ alt12=1;
+ }
+ switch (alt12) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:550:20: '?'
+ {
+ match('?');
+ _type = SEMPRED;
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "ACTION"
+
+ // $ANTLR start "NESTED_ACTION"
+ public final void mNESTED_ACTION() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:554:15: ( '{' ( options {greedy=false; k=2; } : NESTED_ACTION | SL_COMMENT | ML_COMMENT | ACTION_STRING_LITERAL | ACTION_CHAR_LITERAL | . )* '}' )
+ // org/antlr/grammar/v3/ANTLRv3.g:555:2: '{' ( options {greedy=false; k=2; } : NESTED_ACTION | SL_COMMENT | ML_COMMENT | ACTION_STRING_LITERAL | ACTION_CHAR_LITERAL | . )* '}'
+ {
+ match('{');
+ // org/antlr/grammar/v3/ANTLRv3.g:556:2: ( options {greedy=false; k=2; } : NESTED_ACTION | SL_COMMENT | ML_COMMENT | ACTION_STRING_LITERAL | ACTION_CHAR_LITERAL | . )*
+ loop13:
+ do {
+ int alt13=7;
+ alt13 = dfa13.predict(input);
+ switch (alt13) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:557:4: NESTED_ACTION
+ {
+ mNESTED_ACTION();
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:558:4: SL_COMMENT
+ {
+ mSL_COMMENT();
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3.g:559:4: ML_COMMENT
+ {
+ mML_COMMENT();
+
+ }
+ break;
+ case 4 :
+ // org/antlr/grammar/v3/ANTLRv3.g:560:4: ACTION_STRING_LITERAL
+ {
+ mACTION_STRING_LITERAL();
+
+ }
+ break;
+ case 5 :
+ // org/antlr/grammar/v3/ANTLRv3.g:561:4: ACTION_CHAR_LITERAL
+ {
+ mACTION_CHAR_LITERAL();
+
+ }
+ break;
+ case 6 :
+ // org/antlr/grammar/v3/ANTLRv3.g:562:4: .
+ {
+ matchAny();
+
+ }
+ break;
+
+ default :
+ break loop13;
+ }
+ } while (true);
+
+ match('}');
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "NESTED_ACTION"
+
+ // $ANTLR start "ACTION_CHAR_LITERAL"
+ public final void mACTION_CHAR_LITERAL() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:569:2: ( '\\'' ( ACTION_ESC | ~ ( '\\\\' | '\\'' ) ) '\\'' )
+ // org/antlr/grammar/v3/ANTLRv3.g:569:4: '\\'' ( ACTION_ESC | ~ ( '\\\\' | '\\'' ) ) '\\''
+ {
+ match('\'');
+ // org/antlr/grammar/v3/ANTLRv3.g:569:9: ( ACTION_ESC | ~ ( '\\\\' | '\\'' ) )
+ int alt14=2;
+ int LA14_0 = input.LA(1);
+
+ if ( (LA14_0=='\\') ) {
+ alt14=1;
+ }
+ else if ( ((LA14_0>='\u0000' && LA14_0<='&')||(LA14_0>='(' && LA14_0<='[')||(LA14_0>=']' && LA14_0<='\uFFFF')) ) {
+ alt14=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 14, 0, input);
+
+ throw nvae;
+ }
+ switch (alt14) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:569:10: ACTION_ESC
+ {
+ mACTION_ESC();
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:569:21: ~ ( '\\\\' | '\\'' )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ }
+
+ match('\'');
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "ACTION_CHAR_LITERAL"
+
+ // $ANTLR start "ACTION_STRING_LITERAL"
+ public final void mACTION_STRING_LITERAL() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:574:2: ( '\"' ( ACTION_ESC | ~ ( '\\\\' | '\"' ) )* '\"' )
+ // org/antlr/grammar/v3/ANTLRv3.g:574:4: '\"' ( ACTION_ESC | ~ ( '\\\\' | '\"' ) )* '\"'
+ {
+ match('\"');
+ // org/antlr/grammar/v3/ANTLRv3.g:574:8: ( ACTION_ESC | ~ ( '\\\\' | '\"' ) )*
+ loop15:
+ do {
+ int alt15=3;
+ int LA15_0 = input.LA(1);
+
+ if ( (LA15_0=='\\') ) {
+ alt15=1;
+ }
+ else if ( ((LA15_0>='\u0000' && LA15_0<='!')||(LA15_0>='#' && LA15_0<='[')||(LA15_0>=']' && LA15_0<='\uFFFF')) ) {
+ alt15=2;
+ }
+
+
+ switch (alt15) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:574:9: ACTION_ESC
+ {
+ mACTION_ESC();
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:574:20: ~ ( '\\\\' | '\"' )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop15;
+ }
+ } while (true);
+
+ match('\"');
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "ACTION_STRING_LITERAL"
+
+ // $ANTLR start "ACTION_ESC"
+ public final void mACTION_ESC() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:579:2: ( '\\\\\\'' | '\\\\' '\"' | '\\\\' ~ ( '\\'' | '\"' ) )
+ int alt16=3;
+ int LA16_0 = input.LA(1);
+
+ if ( (LA16_0=='\\') ) {
+ int LA16_1 = input.LA(2);
+
+ if ( (LA16_1=='\'') ) {
+ alt16=1;
+ }
+ else if ( (LA16_1=='\"') ) {
+ alt16=2;
+ }
+ else if ( ((LA16_1>='\u0000' && LA16_1<='!')||(LA16_1>='#' && LA16_1<='&')||(LA16_1>='(' && LA16_1<='\uFFFF')) ) {
+ alt16=3;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 16, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 16, 0, input);
+
+ throw nvae;
+ }
+ switch (alt16) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:579:4: '\\\\\\''
+ {
+ match("\\'");
+
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:580:4: '\\\\' '\"'
+ {
+ match('\\');
+ match('\"');
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3.g:581:4: '\\\\' ~ ( '\\'' | '\"' )
+ {
+ match('\\');
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ }
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "ACTION_ESC"
+
+ // $ANTLR start "TOKEN_REF"
+ public final void mTOKEN_REF() throws RecognitionException {
+ try {
+ int _type = TOKEN_REF;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:585:2: ( 'A' .. 'Z' ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* )
+ // org/antlr/grammar/v3/ANTLRv3.g:585:4: 'A' .. 'Z' ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
+ {
+ matchRange('A','Z');
+ // org/antlr/grammar/v3/ANTLRv3.g:585:13: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
+ loop17:
+ do {
+ int alt17=2;
+ int LA17_0 = input.LA(1);
+
+ if ( ((LA17_0>='0' && LA17_0<='9')||(LA17_0>='A' && LA17_0<='Z')||LA17_0=='_'||(LA17_0>='a' && LA17_0<='z')) ) {
+ alt17=1;
+ }
+
+
+ switch (alt17) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:
+ {
+ if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop17;
+ }
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "TOKEN_REF"
+
+ // $ANTLR start "RULE_REF"
+ public final void mRULE_REF() throws RecognitionException {
+ try {
+ int _type = RULE_REF;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:589:2: ( 'a' .. 'z' ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* )
+ // org/antlr/grammar/v3/ANTLRv3.g:589:4: 'a' .. 'z' ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
+ {
+ matchRange('a','z');
+ // org/antlr/grammar/v3/ANTLRv3.g:589:13: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
+ loop18:
+ do {
+ int alt18=2;
+ int LA18_0 = input.LA(1);
+
+ if ( ((LA18_0>='0' && LA18_0<='9')||(LA18_0>='A' && LA18_0<='Z')||LA18_0=='_'||(LA18_0>='a' && LA18_0<='z')) ) {
+ alt18=1;
+ }
+
+
+ switch (alt18) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:
+ {
+ if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop18;
+ }
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_REF"
+
+ // $ANTLR start "OPTIONS"
+ public final void mOPTIONS() throws RecognitionException {
+ try {
+ int _type = OPTIONS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:596:2: ( 'options' WS_LOOP '{' )
+ // org/antlr/grammar/v3/ANTLRv3.g:596:4: 'options' WS_LOOP '{'
+ {
+ match("options");
+
+ mWS_LOOP();
+ match('{');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "OPTIONS"
+
+ // $ANTLR start "TOKENS"
+ public final void mTOKENS() throws RecognitionException {
+ try {
+ int _type = TOKENS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:600:2: ( 'tokens' WS_LOOP '{' )
+ // org/antlr/grammar/v3/ANTLRv3.g:600:4: 'tokens' WS_LOOP '{'
+ {
+ match("tokens");
+
+ mWS_LOOP();
+ match('{');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "TOKENS"
+
+ // $ANTLR start "SRC"
+ public final void mSRC() throws RecognitionException {
+ try {
+ Token file=null;
+ Token line=null;
+
+ // org/antlr/grammar/v3/ANTLRv3.g:608:5: ( 'src' ' ' file= ACTION_STRING_LITERAL ' ' line= INT )
+ // org/antlr/grammar/v3/ANTLRv3.g:608:7: 'src' ' ' file= ACTION_STRING_LITERAL ' ' line= INT
+ {
+ match("src");
+
+ match(' ');
+ int fileStart997 = getCharIndex();
+ mACTION_STRING_LITERAL();
+ file = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, fileStart997, getCharIndex()-1);
+ match(' ');
+ int lineStart1003 = getCharIndex();
+ mINT();
+ line = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, lineStart1003, getCharIndex()-1);
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "SRC"
+
+ // $ANTLR start "WS"
+ public final void mWS() throws RecognitionException {
+ try {
+ int _type = WS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ANTLRv3.g:611:4: ( ( ' ' | '\\t' | ( '\\r' )? '\\n' )+ )
+ // org/antlr/grammar/v3/ANTLRv3.g:611:6: ( ' ' | '\\t' | ( '\\r' )? '\\n' )+
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:611:6: ( ' ' | '\\t' | ( '\\r' )? '\\n' )+
+ int cnt20=0;
+ loop20:
+ do {
+ int alt20=4;
+ switch ( input.LA(1) ) {
+ case ' ':
+ {
+ alt20=1;
+ }
+ break;
+ case '\t':
+ {
+ alt20=2;
+ }
+ break;
+ case '\n':
+ case '\r':
+ {
+ alt20=3;
+ }
+ break;
+
+ }
+
+ switch (alt20) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:611:8: ' '
+ {
+ match(' ');
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:612:5: '\\t'
+ {
+ match('\t');
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3.g:613:5: ( '\\r' )? '\\n'
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:613:5: ( '\\r' )?
+ int alt19=2;
+ int LA19_0 = input.LA(1);
+
+ if ( (LA19_0=='\r') ) {
+ alt19=1;
+ }
+ switch (alt19) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:613:5: '\\r'
+ {
+ match('\r');
+
+ }
+ break;
+
+ }
+
+ match('\n');
+
+ }
+ break;
+
+ default :
+ if ( cnt20 >= 1 ) break loop20;
+ EarlyExitException eee =
+ new EarlyExitException(20, input);
+ throw eee;
+ }
+ cnt20++;
+ } while (true);
+
+ _channel=HIDDEN;
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "WS"
+
+ // $ANTLR start "WS_LOOP"
+ public final void mWS_LOOP() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:620:2: ( ( WS | SL_COMMENT | ML_COMMENT )* )
+ // org/antlr/grammar/v3/ANTLRv3.g:620:4: ( WS | SL_COMMENT | ML_COMMENT )*
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:620:4: ( WS | SL_COMMENT | ML_COMMENT )*
+ loop21:
+ do {
+ int alt21=4;
+ int LA21_0 = input.LA(1);
+
+ if ( ((LA21_0>='\t' && LA21_0<='\n')||LA21_0=='\r'||LA21_0==' ') ) {
+ alt21=1;
+ }
+ else if ( (LA21_0=='/') ) {
+ int LA21_3 = input.LA(2);
+
+ if ( (LA21_3=='/') ) {
+ alt21=2;
+ }
+ else if ( (LA21_3=='*') ) {
+ alt21=3;
+ }
+
+
+ }
+
+
+ switch (alt21) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:620:6: WS
+ {
+ mWS();
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:621:5: SL_COMMENT
+ {
+ mSL_COMMENT();
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3.g:622:5: ML_COMMENT
+ {
+ mML_COMMENT();
+
+ }
+ break;
+
+ default :
+ break loop21;
+ }
+ } while (true);
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "WS_LOOP"
+
+ public void mTokens() throws RecognitionException {
+ // org/antlr/grammar/v3/ANTLRv3.g:1:8: ( RET | SCOPE | FRAGMENT | TREE_BEGIN | ROOT | BANG | RANGE | REWRITE | AT | LABEL_ASSIGN | LIST_LABEL_ASSIGN | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | T__81 | T__82 | T__83 | T__84 | T__85 | T__86 | T__87 | T__88 | T__89 | T__90 | T__91 | T__92 | T__93 | SL_COMMENT | ML_COMMENT | CHAR_LITERAL | STRING_LITERAL | DOUBLE_QUOTE_STRING_LITERAL | DOUBLE_ANGLE_STRING_LITERAL | [...]
+ int alt22=52;
+ alt22 = dfa22.predict(input);
+ switch (alt22) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:10: RET
+ {
+ mRET();
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:14: SCOPE
+ {
+ mSCOPE();
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:20: FRAGMENT
+ {
+ mFRAGMENT();
+
+ }
+ break;
+ case 4 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:29: TREE_BEGIN
+ {
+ mTREE_BEGIN();
+
+ }
+ break;
+ case 5 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:40: ROOT
+ {
+ mROOT();
+
+ }
+ break;
+ case 6 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:45: BANG
+ {
+ mBANG();
+
+ }
+ break;
+ case 7 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:50: RANGE
+ {
+ mRANGE();
+
+ }
+ break;
+ case 8 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:56: REWRITE
+ {
+ mREWRITE();
+
+ }
+ break;
+ case 9 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:64: AT
+ {
+ mAT();
+
+ }
+ break;
+ case 10 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:67: LABEL_ASSIGN
+ {
+ mLABEL_ASSIGN();
+
+ }
+ break;
+ case 11 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:80: LIST_LABEL_ASSIGN
+ {
+ mLIST_LABEL_ASSIGN();
+
+ }
+ break;
+ case 12 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:98: T__67
+ {
+ mT__67();
+
+ }
+ break;
+ case 13 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:104: T__68
+ {
+ mT__68();
+
+ }
+ break;
+ case 14 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:110: T__69
+ {
+ mT__69();
+
+ }
+ break;
+ case 15 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:116: T__70
+ {
+ mT__70();
+
+ }
+ break;
+ case 16 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:122: T__71
+ {
+ mT__71();
+
+ }
+ break;
+ case 17 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:128: T__72
+ {
+ mT__72();
+
+ }
+ break;
+ case 18 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:134: T__73
+ {
+ mT__73();
+
+ }
+ break;
+ case 19 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:140: T__74
+ {
+ mT__74();
+
+ }
+ break;
+ case 20 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:146: T__75
+ {
+ mT__75();
+
+ }
+ break;
+ case 21 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:152: T__76
+ {
+ mT__76();
+
+ }
+ break;
+ case 22 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:158: T__77
+ {
+ mT__77();
+
+ }
+ break;
+ case 23 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:164: T__78
+ {
+ mT__78();
+
+ }
+ break;
+ case 24 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:170: T__79
+ {
+ mT__79();
+
+ }
+ break;
+ case 25 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:176: T__80
+ {
+ mT__80();
+
+ }
+ break;
+ case 26 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:182: T__81
+ {
+ mT__81();
+
+ }
+ break;
+ case 27 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:188: T__82
+ {
+ mT__82();
+
+ }
+ break;
+ case 28 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:194: T__83
+ {
+ mT__83();
+
+ }
+ break;
+ case 29 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:200: T__84
+ {
+ mT__84();
+
+ }
+ break;
+ case 30 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:206: T__85
+ {
+ mT__85();
+
+ }
+ break;
+ case 31 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:212: T__86
+ {
+ mT__86();
+
+ }
+ break;
+ case 32 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:218: T__87
+ {
+ mT__87();
+
+ }
+ break;
+ case 33 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:224: T__88
+ {
+ mT__88();
+
+ }
+ break;
+ case 34 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:230: T__89
+ {
+ mT__89();
+
+ }
+ break;
+ case 35 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:236: T__90
+ {
+ mT__90();
+
+ }
+ break;
+ case 36 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:242: T__91
+ {
+ mT__91();
+
+ }
+ break;
+ case 37 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:248: T__92
+ {
+ mT__92();
+
+ }
+ break;
+ case 38 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:254: T__93
+ {
+ mT__93();
+
+ }
+ break;
+ case 39 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:260: SL_COMMENT
+ {
+ mSL_COMMENT();
+
+ }
+ break;
+ case 40 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:271: ML_COMMENT
+ {
+ mML_COMMENT();
+
+ }
+ break;
+ case 41 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:282: CHAR_LITERAL
+ {
+ mCHAR_LITERAL();
+
+ }
+ break;
+ case 42 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:295: STRING_LITERAL
+ {
+ mSTRING_LITERAL();
+
+ }
+ break;
+ case 43 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:310: DOUBLE_QUOTE_STRING_LITERAL
+ {
+ mDOUBLE_QUOTE_STRING_LITERAL();
+
+ }
+ break;
+ case 44 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:338: DOUBLE_ANGLE_STRING_LITERAL
+ {
+ mDOUBLE_ANGLE_STRING_LITERAL();
+
+ }
+ break;
+ case 45 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:366: INT
+ {
+ mINT();
+
+ }
+ break;
+ case 46 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:370: ARG_ACTION
+ {
+ mARG_ACTION();
+
+ }
+ break;
+ case 47 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:381: ACTION
+ {
+ mACTION();
+
+ }
+ break;
+ case 48 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:388: TOKEN_REF
+ {
+ mTOKEN_REF();
+
+ }
+ break;
+ case 49 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:398: RULE_REF
+ {
+ mRULE_REF();
+
+ }
+ break;
+ case 50 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:407: OPTIONS
+ {
+ mOPTIONS();
+
+ }
+ break;
+ case 51 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:415: TOKENS
+ {
+ mTOKENS();
+
+ }
+ break;
+ case 52 :
+ // org/antlr/grammar/v3/ANTLRv3.g:1:422: WS
+ {
+ mWS();
+
+ }
+ break;
+
+ }
+
+ }
+
+
+ protected DFA2 dfa2 = new DFA2(this);
+ protected DFA9 dfa9 = new DFA9(this);
+ protected DFA13 dfa13 = new DFA13(this);
+ protected DFA22 dfa22 = new DFA22(this);
+ static final String DFA2_eotS =
+ "\20\uffff\1\2\7\uffff\1\2\3\uffff";
+ static final String DFA2_eofS =
+ "\34\uffff";
+ static final String DFA2_minS =
+ "\2\0\1\uffff\21\0\1\uffff\6\0\1\uffff";
+ static final String DFA2_maxS =
+ "\2\uffff\1\uffff\21\uffff\1\uffff\6\uffff\1\uffff";
+ static final String DFA2_acceptS =
+ "\2\uffff\1\2\21\uffff\1\1\6\uffff\1\1";
+ static final String DFA2_specialS =
+ "\1\16\1\21\1\uffff\1\17\1\23\1\22\1\27\1\25\1\30\1\10\1\1\1\2\1"+
+ "\0\1\13\1\12\1\5\1\11\1\6\1\4\1\7\1\uffff\1\20\1\26\1\3\1\24\1\15"+
+ "\1\14\1\uffff}>";
+ static final String[] DFA2_transitionS = {
+ "\40\2\1\1\uffdf\2",
+ "\44\2\1\3\uffdb\2",
+ "",
+ "\101\2\1\4\uffbe\2",
+ "\116\2\1\5\uffb1\2",
+ "\124\2\1\6\uffab\2",
+ "\114\2\1\7\uffb3\2",
+ "\122\2\1\10\uffad\2",
+ "\40\2\1\11\uffdf\2",
+ "\163\2\1\12\uff8c\2",
+ "\162\2\1\13\uff8d\2",
+ "\143\2\1\14\uff9c\2",
+ "\40\2\1\15\uffdf\2",
+ "\42\2\1\16\uffdd\2",
+ "\12\22\1\20\2\22\1\17\24\22\1\23\71\22\1\21\uffa3\22",
+ "\12\24\1\20\ufff5\24",
+ "\0\24",
+ "\12\31\1\30\2\31\1\27\24\31\1\26\4\31\1\25\uffd8\31",
+ "\12\22\1\20\2\22\1\17\24\22\1\23\71\22\1\21\uffa3\22",
+ "\40\2\1\32\uffdf\2",
+ "",
+ "\12\22\1\20\2\22\1\17\24\22\1\23\71\22\1\21\uffa3\22",
+ "\12\22\1\20\2\22\1\17\24\22\1\23\71\22\1\21\uffa3\22",
+ "\12\24\1\20\ufff5\24",
+ "\0\24",
+ "\12\22\1\20\2\22\1\17\24\22\1\23\71\22\1\21\uffa3\22",
+ "\60\2\12\33\uffc6\2",
+ ""
+ };
+
+ static final short[] DFA2_eot = DFA.unpackEncodedString(DFA2_eotS);
+ static final short[] DFA2_eof = DFA.unpackEncodedString(DFA2_eofS);
+ static final char[] DFA2_min = DFA.unpackEncodedStringToUnsignedChars(DFA2_minS);
+ static final char[] DFA2_max = DFA.unpackEncodedStringToUnsignedChars(DFA2_maxS);
+ static final short[] DFA2_accept = DFA.unpackEncodedString(DFA2_acceptS);
+ static final short[] DFA2_special = DFA.unpackEncodedString(DFA2_specialS);
+ static final short[][] DFA2_transition;
+
+ static {
+ int numStates = DFA2_transitionS.length;
+ DFA2_transition = new short[numStates][];
+ for (int i=0; i<numStates; i++) {
+ DFA2_transition[i] = DFA.unpackEncodedString(DFA2_transitionS[i]);
+ }
+ }
+
+ class DFA2 extends DFA {
+
+ public DFA2(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 2;
+ this.eot = DFA2_eot;
+ this.eof = DFA2_eof;
+ this.min = DFA2_min;
+ this.max = DFA2_max;
+ this.accept = DFA2_accept;
+ this.special = DFA2_special;
+ this.transition = DFA2_transition;
+ }
+ public String getDescription() {
+ return "473:5: ( ' $ANTLR ' SRC | (~ ( '\\r' | '\\n' ) )* )";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ IntStream input = _input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA2_12 = input.LA(1);
+
+ s = -1;
+ if ( (LA2_12==' ') ) {s = 13;}
+
+ else if ( ((LA2_12>='\u0000' && LA2_12<='\u001F')||(LA2_12>='!' && LA2_12<='\uFFFF')) ) {s = 2;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA2_10 = input.LA(1);
+
+ s = -1;
+ if ( (LA2_10=='r') ) {s = 11;}
+
+ else if ( ((LA2_10>='\u0000' && LA2_10<='q')||(LA2_10>='s' && LA2_10<='\uFFFF')) ) {s = 2;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA2_11 = input.LA(1);
+
+ s = -1;
+ if ( (LA2_11=='c') ) {s = 12;}
+
+ else if ( ((LA2_11>='\u0000' && LA2_11<='b')||(LA2_11>='d' && LA2_11<='\uFFFF')) ) {s = 2;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 3 :
+ int LA2_23 = input.LA(1);
+
+ s = -1;
+ if ( (LA2_23=='\n') ) {s = 16;}
+
+ else if ( ((LA2_23>='\u0000' && LA2_23<='\t')||(LA2_23>='\u000B' && LA2_23<='\uFFFF')) ) {s = 20;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 4 :
+ int LA2_18 = input.LA(1);
+
+ s = -1;
+ if ( (LA2_18=='\"') ) {s = 19;}
+
+ else if ( (LA2_18=='\\') ) {s = 17;}
+
+ else if ( (LA2_18=='\r') ) {s = 15;}
+
+ else if ( (LA2_18=='\n') ) {s = 16;}
+
+ else if ( ((LA2_18>='\u0000' && LA2_18<='\t')||(LA2_18>='\u000B' && LA2_18<='\f')||(LA2_18>='\u000E' && LA2_18<='!')||(LA2_18>='#' && LA2_18<='[')||(LA2_18>=']' && LA2_18<='\uFFFF')) ) {s = 18;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 5 :
+ int LA2_15 = input.LA(1);
+
+ s = -1;
+ if ( (LA2_15=='\n') ) {s = 16;}
+
+ else if ( ((LA2_15>='\u0000' && LA2_15<='\t')||(LA2_15>='\u000B' && LA2_15<='\uFFFF')) ) {s = 20;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 6 :
+ int LA2_17 = input.LA(1);
+
+ s = -1;
+ if ( (LA2_17=='\'') ) {s = 21;}
+
+ else if ( (LA2_17=='\"') ) {s = 22;}
+
+ else if ( (LA2_17=='\r') ) {s = 23;}
+
+ else if ( (LA2_17=='\n') ) {s = 24;}
+
+ else if ( ((LA2_17>='\u0000' && LA2_17<='\t')||(LA2_17>='\u000B' && LA2_17<='\f')||(LA2_17>='\u000E' && LA2_17<='!')||(LA2_17>='#' && LA2_17<='&')||(LA2_17>='(' && LA2_17<='\uFFFF')) ) {s = 25;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 7 :
+ int LA2_19 = input.LA(1);
+
+ s = -1;
+ if ( ((LA2_19>='\u0000' && LA2_19<='\u001F')||(LA2_19>='!' && LA2_19<='\uFFFF')) ) {s = 2;}
+
+ else if ( (LA2_19==' ') ) {s = 26;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 8 :
+ int LA2_9 = input.LA(1);
+
+ s = -1;
+ if ( (LA2_9=='s') ) {s = 10;}
+
+ else if ( ((LA2_9>='\u0000' && LA2_9<='r')||(LA2_9>='t' && LA2_9<='\uFFFF')) ) {s = 2;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 9 :
+ int LA2_16 = input.LA(1);
+
+ s = -1;
+ if ( ((LA2_16>='\u0000' && LA2_16<='\uFFFF')) ) {s = 20;}
+
+ else s = 2;
+
+ if ( s>=0 ) return s;
+ break;
+ case 10 :
+ int LA2_14 = input.LA(1);
+
+ s = -1;
+ if ( (LA2_14=='\r') ) {s = 15;}
+
+ else if ( (LA2_14=='\n') ) {s = 16;}
+
+ else if ( (LA2_14=='\\') ) {s = 17;}
+
+ else if ( ((LA2_14>='\u0000' && LA2_14<='\t')||(LA2_14>='\u000B' && LA2_14<='\f')||(LA2_14>='\u000E' && LA2_14<='!')||(LA2_14>='#' && LA2_14<='[')||(LA2_14>=']' && LA2_14<='\uFFFF')) ) {s = 18;}
+
+ else if ( (LA2_14=='\"') ) {s = 19;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 11 :
+ int LA2_13 = input.LA(1);
+
+ s = -1;
+ if ( ((LA2_13>='\u0000' && LA2_13<='!')||(LA2_13>='#' && LA2_13<='\uFFFF')) ) {s = 2;}
+
+ else if ( (LA2_13=='\"') ) {s = 14;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 12 :
+ int LA2_26 = input.LA(1);
+
+ s = -1;
+ if ( ((LA2_26>='\u0000' && LA2_26<='/')||(LA2_26>=':' && LA2_26<='\uFFFF')) ) {s = 2;}
+
+ else if ( ((LA2_26>='0' && LA2_26<='9')) ) {s = 27;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 13 :
+ int LA2_25 = input.LA(1);
+
+ s = -1;
+ if ( (LA2_25=='\"') ) {s = 19;}
+
+ else if ( (LA2_25=='\\') ) {s = 17;}
+
+ else if ( (LA2_25=='\r') ) {s = 15;}
+
+ else if ( (LA2_25=='\n') ) {s = 16;}
+
+ else if ( ((LA2_25>='\u0000' && LA2_25<='\t')||(LA2_25>='\u000B' && LA2_25<='\f')||(LA2_25>='\u000E' && LA2_25<='!')||(LA2_25>='#' && LA2_25<='[')||(LA2_25>=']' && LA2_25<='\uFFFF')) ) {s = 18;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 14 :
+ int LA2_0 = input.LA(1);
+
+ s = -1;
+ if ( (LA2_0==' ') ) {s = 1;}
+
+ else if ( ((LA2_0>='\u0000' && LA2_0<='\u001F')||(LA2_0>='!' && LA2_0<='\uFFFF')) ) {s = 2;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 15 :
+ int LA2_3 = input.LA(1);
+
+ s = -1;
+ if ( (LA2_3=='A') ) {s = 4;}
+
+ else if ( ((LA2_3>='\u0000' && LA2_3<='@')||(LA2_3>='B' && LA2_3<='\uFFFF')) ) {s = 2;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 16 :
+ int LA2_21 = input.LA(1);
+
+ s = -1;
+ if ( (LA2_21=='\r') ) {s = 15;}
+
+ else if ( (LA2_21=='\n') ) {s = 16;}
+
+ else if ( (LA2_21=='\"') ) {s = 19;}
+
+ else if ( (LA2_21=='\\') ) {s = 17;}
+
+ else if ( ((LA2_21>='\u0000' && LA2_21<='\t')||(LA2_21>='\u000B' && LA2_21<='\f')||(LA2_21>='\u000E' && LA2_21<='!')||(LA2_21>='#' && LA2_21<='[')||(LA2_21>=']' && LA2_21<='\uFFFF')) ) {s = 18;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 17 :
+ int LA2_1 = input.LA(1);
+
+ s = -1;
+ if ( (LA2_1=='$') ) {s = 3;}
+
+ else if ( ((LA2_1>='\u0000' && LA2_1<='#')||(LA2_1>='%' && LA2_1<='\uFFFF')) ) {s = 2;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 18 :
+ int LA2_5 = input.LA(1);
+
+ s = -1;
+ if ( (LA2_5=='T') ) {s = 6;}
+
+ else if ( ((LA2_5>='\u0000' && LA2_5<='S')||(LA2_5>='U' && LA2_5<='\uFFFF')) ) {s = 2;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 19 :
+ int LA2_4 = input.LA(1);
+
+ s = -1;
+ if ( (LA2_4=='N') ) {s = 5;}
+
+ else if ( ((LA2_4>='\u0000' && LA2_4<='M')||(LA2_4>='O' && LA2_4<='\uFFFF')) ) {s = 2;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 20 :
+ int LA2_24 = input.LA(1);
+
+ s = -1;
+ if ( ((LA2_24>='\u0000' && LA2_24<='\uFFFF')) ) {s = 20;}
+
+ else s = 2;
+
+ if ( s>=0 ) return s;
+ break;
+ case 21 :
+ int LA2_7 = input.LA(1);
+
+ s = -1;
+ if ( (LA2_7=='R') ) {s = 8;}
+
+ else if ( ((LA2_7>='\u0000' && LA2_7<='Q')||(LA2_7>='S' && LA2_7<='\uFFFF')) ) {s = 2;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 22 :
+ int LA2_22 = input.LA(1);
+
+ s = -1;
+ if ( (LA2_22=='\r') ) {s = 15;}
+
+ else if ( (LA2_22=='\n') ) {s = 16;}
+
+ else if ( (LA2_22=='\"') ) {s = 19;}
+
+ else if ( (LA2_22=='\\') ) {s = 17;}
+
+ else if ( ((LA2_22>='\u0000' && LA2_22<='\t')||(LA2_22>='\u000B' && LA2_22<='\f')||(LA2_22>='\u000E' && LA2_22<='!')||(LA2_22>='#' && LA2_22<='[')||(LA2_22>=']' && LA2_22<='\uFFFF')) ) {s = 18;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 23 :
+ int LA2_6 = input.LA(1);
+
+ s = -1;
+ if ( (LA2_6=='L') ) {s = 7;}
+
+ else if ( ((LA2_6>='\u0000' && LA2_6<='K')||(LA2_6>='M' && LA2_6<='\uFFFF')) ) {s = 2;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 24 :
+ int LA2_8 = input.LA(1);
+
+ s = -1;
+ if ( (LA2_8==' ') ) {s = 9;}
+
+ else if ( ((LA2_8>='\u0000' && LA2_8<='\u001F')||(LA2_8>='!' && LA2_8<='\uFFFF')) ) {s = 2;}
+
+ if ( s>=0 ) return s;
+ break;
+ }
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 2, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String DFA9_eotS =
+ "\12\uffff\1\13\2\uffff";
+ static final String DFA9_eofS =
+ "\15\uffff";
+ static final String DFA9_minS =
+ "\1\0\11\uffff\1\60\2\uffff";
+ static final String DFA9_maxS =
+ "\1\uffff\11\uffff\1\146\2\uffff";
+ static final String DFA9_acceptS =
+ "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\uffff\1\13\1\12";
+ static final String DFA9_specialS =
+ "\1\0\14\uffff}>";
+ static final String[] DFA9_transitionS = {
+ "\42\13\1\6\4\13\1\7\26\13\1\11\35\13\1\10\5\13\1\4\3\13\1\5"+
+ "\7\13\1\1\3\13\1\2\1\13\1\3\1\12\uff8a\13",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\12\14\7\uffff\6\14\32\uffff\6\14",
+ "",
+ ""
+ };
+
+ static final short[] DFA9_eot = DFA.unpackEncodedString(DFA9_eotS);
+ static final short[] DFA9_eof = DFA.unpackEncodedString(DFA9_eofS);
+ static final char[] DFA9_min = DFA.unpackEncodedStringToUnsignedChars(DFA9_minS);
+ static final char[] DFA9_max = DFA.unpackEncodedStringToUnsignedChars(DFA9_maxS);
+ static final short[] DFA9_accept = DFA.unpackEncodedString(DFA9_acceptS);
+ static final short[] DFA9_special = DFA.unpackEncodedString(DFA9_specialS);
+ static final short[][] DFA9_transition;
+
+ static {
+ int numStates = DFA9_transitionS.length;
+ DFA9_transition = new short[numStates][];
+ for (int i=0; i<numStates; i++) {
+ DFA9_transition[i] = DFA.unpackEncodedString(DFA9_transitionS[i]);
+ }
+ }
+
+ class DFA9 extends DFA {
+
+ public DFA9(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 9;
+ this.eot = DFA9_eot;
+ this.eof = DFA9_eof;
+ this.min = DFA9_min;
+ this.max = DFA9_max;
+ this.accept = DFA9_accept;
+ this.special = DFA9_special;
+ this.transition = DFA9_transition;
+ }
+ public String getDescription() {
+ return "508:3: ( 'n' | 'r' | 't' | 'b' | 'f' | '\"' | '\\'' | '\\\\' | '>' | 'u' XDIGIT XDIGIT XDIGIT XDIGIT | . )";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ IntStream input = _input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA9_0 = input.LA(1);
+
+ s = -1;
+ if ( (LA9_0=='n') ) {s = 1;}
+
+ else if ( (LA9_0=='r') ) {s = 2;}
+
+ else if ( (LA9_0=='t') ) {s = 3;}
+
+ else if ( (LA9_0=='b') ) {s = 4;}
+
+ else if ( (LA9_0=='f') ) {s = 5;}
+
+ else if ( (LA9_0=='\"') ) {s = 6;}
+
+ else if ( (LA9_0=='\'') ) {s = 7;}
+
+ else if ( (LA9_0=='\\') ) {s = 8;}
+
+ else if ( (LA9_0=='>') ) {s = 9;}
+
+ else if ( (LA9_0=='u') ) {s = 10;}
+
+ else if ( ((LA9_0>='\u0000' && LA9_0<='!')||(LA9_0>='#' && LA9_0<='&')||(LA9_0>='(' && LA9_0<='=')||(LA9_0>='?' && LA9_0<='[')||(LA9_0>=']' && LA9_0<='a')||(LA9_0>='c' && LA9_0<='e')||(LA9_0>='g' && LA9_0<='m')||(LA9_0>='o' && LA9_0<='q')||LA9_0=='s'||(LA9_0>='v' && LA9_0<='\uFFFF')) ) {s = 11;}
+
+ if ( s>=0 ) return s;
+ break;
+ }
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 9, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String DFA13_eotS =
+ "\34\uffff";
+ static final String DFA13_eofS =
+ "\34\uffff";
+ static final String DFA13_minS =
+ "\1\0\2\uffff\3\0\26\uffff";
+ static final String DFA13_maxS =
+ "\1\uffff\2\uffff\3\uffff\26\uffff";
+ static final String DFA13_acceptS =
+ "\1\uffff\1\7\1\1\3\uffff\1\6\1\2\1\3\5\uffff\7\4\6\5\1\uffff";
+ static final String DFA13_specialS =
+ "\1\0\2\uffff\1\1\1\2\1\3\26\uffff}>";
+ static final String[] DFA13_transitionS = {
+ "\42\6\1\4\4\6\1\5\7\6\1\3\113\6\1\2\1\6\1\1\uff82\6",
+ "",
+ "",
+ "\52\6\1\10\4\6\1\7\uffd0\6",
+ "\42\24\1\21\4\24\1\22\7\24\1\20\54\24\1\23\36\24\1\17\1\24"+
+ "\1\16\uff82\24",
+ "\42\32\1\31\4\32\1\6\7\32\1\30\54\32\1\25\36\32\1\27\1\32\1"+
+ "\26\uff82\32",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] DFA13_eot = DFA.unpackEncodedString(DFA13_eotS);
+ static final short[] DFA13_eof = DFA.unpackEncodedString(DFA13_eofS);
+ static final char[] DFA13_min = DFA.unpackEncodedStringToUnsignedChars(DFA13_minS);
+ static final char[] DFA13_max = DFA.unpackEncodedStringToUnsignedChars(DFA13_maxS);
+ static final short[] DFA13_accept = DFA.unpackEncodedString(DFA13_acceptS);
+ static final short[] DFA13_special = DFA.unpackEncodedString(DFA13_specialS);
+ static final short[][] DFA13_transition;
+
+ static {
+ int numStates = DFA13_transitionS.length;
+ DFA13_transition = new short[numStates][];
+ for (int i=0; i<numStates; i++) {
+ DFA13_transition[i] = DFA.unpackEncodedString(DFA13_transitionS[i]);
+ }
+ }
+
+ class DFA13 extends DFA {
+
+ public DFA13(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 13;
+ this.eot = DFA13_eot;
+ this.eof = DFA13_eof;
+ this.min = DFA13_min;
+ this.max = DFA13_max;
+ this.accept = DFA13_accept;
+ this.special = DFA13_special;
+ this.transition = DFA13_transition;
+ }
+ public String getDescription() {
+ return "()* loopback of 556:2: ( options {greedy=false; k=2; } : NESTED_ACTION | SL_COMMENT | ML_COMMENT | ACTION_STRING_LITERAL | ACTION_CHAR_LITERAL | . )*";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ IntStream input = _input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA13_0 = input.LA(1);
+
+ s = -1;
+ if ( (LA13_0=='}') ) {s = 1;}
+
+ else if ( (LA13_0=='{') ) {s = 2;}
+
+ else if ( (LA13_0=='/') ) {s = 3;}
+
+ else if ( (LA13_0=='\"') ) {s = 4;}
+
+ else if ( (LA13_0=='\'') ) {s = 5;}
+
+ else if ( ((LA13_0>='\u0000' && LA13_0<='!')||(LA13_0>='#' && LA13_0<='&')||(LA13_0>='(' && LA13_0<='.')||(LA13_0>='0' && LA13_0<='z')||LA13_0=='|'||(LA13_0>='~' && LA13_0<='\uFFFF')) ) {s = 6;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA13_3 = input.LA(1);
+
+ s = -1;
+ if ( (LA13_3=='/') ) {s = 7;}
+
+ else if ( (LA13_3=='*') ) {s = 8;}
+
+ else if ( ((LA13_3>='\u0000' && LA13_3<=')')||(LA13_3>='+' && LA13_3<='.')||(LA13_3>='0' && LA13_3<='\uFFFF')) ) {s = 6;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA13_4 = input.LA(1);
+
+ s = -1;
+ if ( (LA13_4=='}') ) {s = 14;}
+
+ else if ( (LA13_4=='{') ) {s = 15;}
+
+ else if ( (LA13_4=='/') ) {s = 16;}
+
+ else if ( (LA13_4=='\"') ) {s = 17;}
+
+ else if ( (LA13_4=='\'') ) {s = 18;}
+
+ else if ( (LA13_4=='\\') ) {s = 19;}
+
+ else if ( ((LA13_4>='\u0000' && LA13_4<='!')||(LA13_4>='#' && LA13_4<='&')||(LA13_4>='(' && LA13_4<='.')||(LA13_4>='0' && LA13_4<='[')||(LA13_4>=']' && LA13_4<='z')||LA13_4=='|'||(LA13_4>='~' && LA13_4<='\uFFFF')) ) {s = 20;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 3 :
+ int LA13_5 = input.LA(1);
+
+ s = -1;
+ if ( (LA13_5=='\\') ) {s = 21;}
+
+ else if ( (LA13_5=='}') ) {s = 22;}
+
+ else if ( (LA13_5=='{') ) {s = 23;}
+
+ else if ( (LA13_5=='/') ) {s = 24;}
+
+ else if ( (LA13_5=='\"') ) {s = 25;}
+
+ else if ( ((LA13_5>='\u0000' && LA13_5<='!')||(LA13_5>='#' && LA13_5<='&')||(LA13_5>='(' && LA13_5<='.')||(LA13_5>='0' && LA13_5<='[')||(LA13_5>=']' && LA13_5<='z')||LA13_5=='|'||(LA13_5>='~' && LA13_5<='\uFFFF')) ) {s = 26;}
+
+ else if ( (LA13_5=='\'') ) {s = 6;}
+
+ if ( s>=0 ) return s;
+ break;
+ }
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 13, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String DFA22_eotS =
+ "\1\uffff\3\45\1\54\1\uffff\1\56\2\uffff\1\60\1\62\4\45\2\uffff\1"+
+ "\74\5\uffff\1\45\1\uffff\1\77\12\uffff\1\45\2\uffff\4\45\10\uffff"+
+ "\10\45\2\uffff\1\45\6\uffff\17\45\15\uffff\12\45\1\173\4\45\2\uffff"+
+ "\2\45\1\u0083\2\45\1\u0086\4\45\1\uffff\3\45\1\u008e\1\uffff\2\45"+
+ "\1\uffff\2\45\1\uffff\1\u0094\2\45\1\u0097\1\u0098\2\45\2\uffff"+
+ "\1\45\1\u009d\1\45\1\u009f\1\uffff\1\45\1\u00a1\3\uffff\1\u00a2"+
+ "\1\uffff\1\45\1\uffff\1\u00a4\1\uffff\1\45\4\uffff\1\u00a6\1\uffff";
+ static final String DFA22_eofS =
+ "\u00a7\uffff";
+ static final String DFA22_minS =
+ "\1\11\1\145\1\143\1\151\1\50\1\uffff\1\56\2\uffff\1\76\1\75\1\145"+
+ "\1\141\1\150\1\162\2\uffff\1\72\5\uffff\1\141\1\uffff\1\74\3\uffff"+
+ "\1\52\1\0\5\uffff\1\160\2\uffff\1\164\1\157\1\141\1\156\10\uffff"+
+ "\1\170\1\162\1\151\1\142\1\145\1\162\1\153\1\141\2\uffff\1\164\4"+
+ "\uffff\2\0\1\164\1\165\1\160\1\147\1\141\1\145\1\163\1\164\1\166"+
+ "\1\154\1\145\1\157\1\145\1\155\1\143\13\0\2\uffff\1\151\1\162\1"+
+ "\145\1\155\1\154\1\162\2\145\1\141\1\151\1\60\1\167\1\156\1\155"+
+ "\1\150\1\0\1\uffff\1\157\1\156\1\60\1\145\1\154\1\60\1\162\1\143"+
+ "\1\164\1\143\1\uffff\2\163\1\141\1\60\1\0\1\156\1\163\1\uffff\1"+
+ "\156\1\171\1\uffff\1\60\1\164\1\145\2\60\1\11\1\162\1\uffff\1\0"+
+ "\1\163\1\60\1\164\1\60\1\uffff\1\145\1\60\3\uffff\1\60\1\0\1\11"+
+ "\1\uffff\1\60\1\uffff\1\144\4\uffff\1\60\1\uffff";
+ static final String DFA22_maxS =
+ "\1\176\1\145\1\143\1\162\1\50\1\uffff\1\56\2\uffff\1\76\1\75\1\145"+
+ "\1\165\2\162\2\uffff\1\72\5\uffff\1\141\1\uffff\1\74\3\uffff\1\57"+
+ "\1\uffff\5\uffff\1\160\2\uffff\1\164\1\157\1\141\1\156\10\uffff"+
+ "\1\170\1\162\1\157\1\142\1\145\1\162\1\153\1\141\2\uffff\1\164\4"+
+ "\uffff\2\uffff\1\164\1\165\1\160\1\147\1\141\1\145\1\163\1\164\1"+
+ "\166\1\154\1\145\1\157\1\145\1\155\1\143\13\uffff\2\uffff\1\151"+
+ "\1\162\1\145\1\155\1\154\1\162\2\145\1\141\1\151\1\172\1\167\1\156"+
+ "\1\155\1\150\1\uffff\1\uffff\1\157\1\156\1\172\1\145\1\154\1\172"+
+ "\1\162\1\143\1\164\1\143\1\uffff\2\163\1\141\1\172\1\uffff\1\156"+
+ "\1\163\1\uffff\1\156\1\171\1\uffff\1\172\1\164\1\145\2\172\1\173"+
+ "\1\162\1\uffff\1\uffff\1\163\1\172\1\164\1\172\1\uffff\1\145\1\172"+
+ "\3\uffff\1\172\1\uffff\1\173\1\uffff\1\172\1\uffff\1\144\4\uffff"+
+ "\1\172\1\uffff";
+ static final String DFA22_acceptS =
+ "\5\uffff\1\6\1\uffff\1\10\1\11\6\uffff\1\20\1\21\1\uffff\1\23\1"+
+ "\31\1\32\1\33\1\34\1\uffff\1\40\1\uffff\1\42\1\44\1\46\2\uffff\1"+
+ "\53\1\55\1\56\1\57\1\60\1\uffff\1\61\1\64\4\uffff\1\4\1\5\1\7\1"+
+ "\43\1\37\1\12\1\13\1\45\10\uffff\1\22\1\27\1\uffff\1\54\1\41\1\47"+
+ "\1\50\34\uffff\1\52\1\51\20\uffff\1\51\12\uffff\1\16\7\uffff\1\2"+
+ "\2\uffff\1\14\7\uffff\1\35\5\uffff\1\15\2\uffff\1\25\1\30\1\63\3"+
+ "\uffff\1\1\1\uffff\1\36\1\uffff\1\26\1\17\1\62\1\3\1\uffff\1\24";
+ static final String DFA22_specialS =
+ "\36\uffff\1\11\43\uffff\1\1\1\0\17\uffff\1\12\1\15\1\13\1\21\1\17"+
+ "\1\4\1\5\1\6\1\7\1\3\1\10\21\uffff\1\14\20\uffff\1\16\16\uffff\1"+
+ "\20\13\uffff\1\2\13\uffff}>";
+ static final String[] DFA22_transitionS = {
+ "\2\46\2\uffff\1\46\22\uffff\1\46\1\5\1\37\1\uffff\1\34\2\uffff"+
+ "\1\36\1\24\1\26\1\22\1\12\1\23\1\7\1\6\1\35\12\40\1\21\1\17"+
+ "\1\31\1\11\1\32\1\33\1\10\32\43\1\41\2\uffff\1\4\2\uffff\2\45"+
+ "\1\27\2\45\1\3\1\16\4\45\1\13\2\45\1\44\1\14\1\45\1\1\1\2\1"+
+ "\15\6\45\1\42\1\25\1\20\1\30",
+ "\1\47",
+ "\1\50",
+ "\1\52\10\uffff\1\51",
+ "\1\53",
+ "",
+ "\1\55",
+ "",
+ "",
+ "\1\57",
+ "\1\61",
+ "\1\63",
+ "\1\64\20\uffff\1\65\2\uffff\1\66",
+ "\1\70\6\uffff\1\71\2\uffff\1\67",
+ "\1\72",
+ "",
+ "",
+ "\1\73",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\75",
+ "",
+ "\1\76",
+ "",
+ "",
+ "",
+ "\1\101\4\uffff\1\100",
+ "\47\103\1\uffff\64\103\1\102\uffa3\103",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\104",
+ "",
+ "",
+ "\1\105",
+ "\1\106",
+ "\1\107",
+ "\1\110",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\111",
+ "\1\112",
+ "\1\114\5\uffff\1\113",
+ "\1\115",
+ "\1\116",
+ "\1\117",
+ "\1\120",
+ "\1\121",
+ "",
+ "",
+ "\1\122",
+ "",
+ "",
+ "",
+ "",
+ "\42\135\1\130\4\135\1\131\26\135\1\133\35\135\1\132\5\135\1"+
+ "\126\3\135\1\127\7\135\1\123\3\135\1\124\1\135\1\125\1\134\uff8a"+
+ "\135",
+ "\47\136\1\137\uffd8\136",
+ "\1\140",
+ "\1\141",
+ "\1\142",
+ "\1\143",
+ "\1\144",
+ "\1\145",
+ "\1\146",
+ "\1\147",
+ "\1\150",
+ "\1\151",
+ "\1\152",
+ "\1\153",
+ "\1\154",
+ "\1\155",
+ "\1\156",
+ "\47\136\1\137\uffd8\136",
+ "\47\136\1\137\uffd8\136",
+ "\47\136\1\137\uffd8\136",
+ "\47\136\1\137\uffd8\136",
+ "\47\136\1\137\uffd8\136",
+ "\47\136\1\137\uffd8\136",
+ "\47\136\1\137\uffd8\136",
+ "\47\136\1\137\uffd8\136",
+ "\47\136\1\137\uffd8\136",
+ "\47\136\1\137\10\136\12\157\7\136\6\157\32\136\6\157\uff99"+
+ "\136",
+ "\47\136\1\137\uffd8\136",
+ "",
+ "",
+ "\1\161",
+ "\1\162",
+ "\1\163",
+ "\1\164",
+ "\1\165",
+ "\1\166",
+ "\1\167",
+ "\1\170",
+ "\1\171",
+ "\1\172",
+ "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
+ "\1\174",
+ "\1\175",
+ "\1\176",
+ "\1\177",
+ "\60\136\12\u0080\7\136\6\u0080\32\136\6\u0080\uff99\136",
+ "",
+ "\1\u0081",
+ "\1\u0082",
+ "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
+ "\1\u0084",
+ "\1\u0085",
+ "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
+ "\1\u0087",
+ "\1\u0088",
+ "\1\u0089",
+ "\1\u008a",
+ "",
+ "\1\u008b",
+ "\1\u008c",
+ "\1\u008d",
+ "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
+ "\60\136\12\u008f\7\136\6\u008f\32\136\6\u008f\uff99\136",
+ "\1\u0090",
+ "\1\u0091",
+ "",
+ "\1\u0092",
+ "\1\u0093",
+ "",
+ "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
+ "\1\u0095",
+ "\1\u0096",
+ "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
+ "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
+ "\2\u0099\2\uffff\1\u0099\22\uffff\1\u0099\16\uffff\1\u0099"+
+ "\113\uffff\1\u0099",
+ "\1\u009a",
+ "",
+ "\60\136\12\u009b\7\136\6\u009b\32\136\6\u009b\uff99\136",
+ "\1\u009c",
+ "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
+ "\1\u009e",
+ "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
+ "",
+ "\1\u00a0",
+ "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
+ "",
+ "",
+ "",
+ "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
+ "\47\136\1\137\uffd8\136",
+ "\2\u00a3\2\uffff\1\u00a3\22\uffff\1\u00a3\16\uffff\1\u00a3"+
+ "\113\uffff\1\u00a3",
+ "",
+ "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
+ "",
+ "\1\u00a5",
+ "",
+ "",
+ "",
+ "",
+ "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
+ ""
+ };
+
+ static final short[] DFA22_eot = DFA.unpackEncodedString(DFA22_eotS);
+ static final short[] DFA22_eof = DFA.unpackEncodedString(DFA22_eofS);
+ static final char[] DFA22_min = DFA.unpackEncodedStringToUnsignedChars(DFA22_minS);
+ static final char[] DFA22_max = DFA.unpackEncodedStringToUnsignedChars(DFA22_maxS);
+ static final short[] DFA22_accept = DFA.unpackEncodedString(DFA22_acceptS);
+ static final short[] DFA22_special = DFA.unpackEncodedString(DFA22_specialS);
+ static final short[][] DFA22_transition;
+
+ static {
+ int numStates = DFA22_transitionS.length;
+ DFA22_transition = new short[numStates][];
+ for (int i=0; i<numStates; i++) {
+ DFA22_transition[i] = DFA.unpackEncodedString(DFA22_transitionS[i]);
+ }
+ }
+
+ class DFA22 extends DFA {
+
+ public DFA22(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 22;
+ this.eot = DFA22_eot;
+ this.eof = DFA22_eof;
+ this.min = DFA22_min;
+ this.max = DFA22_max;
+ this.accept = DFA22_accept;
+ this.special = DFA22_special;
+ this.transition = DFA22_transition;
+ }
+ public String getDescription() {
+ return "1:1: Tokens : ( RET | SCOPE | FRAGMENT | TREE_BEGIN | ROOT | BANG | RANGE | REWRITE | AT | LABEL_ASSIGN | LIST_LABEL_ASSIGN | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | T__81 | T__82 | T__83 | T__84 | T__85 | T__86 | T__87 | T__88 | T__89 | T__90 | T__91 | T__92 | T__93 | SL_COMMENT | ML_COMMENT | CHAR_LITERAL | STRING_LITERAL | DOUBLE_QUOTE_STRING_LITERAL | DOUBLE_ANGLE_STRING_LITERAL | INT | ARG_AC [...]
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ IntStream input = _input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA22_67 = input.LA(1);
+
+ s = -1;
+ if ( ((LA22_67>='\u0000' && LA22_67<='&')||(LA22_67>='(' && LA22_67<='\uFFFF')) ) {s = 94;}
+
+ else if ( (LA22_67=='\'') ) {s = 95;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA22_66 = input.LA(1);
+
+ s = -1;
+ if ( (LA22_66=='n') ) {s = 83;}
+
+ else if ( (LA22_66=='r') ) {s = 84;}
+
+ else if ( (LA22_66=='t') ) {s = 85;}
+
+ else if ( (LA22_66=='b') ) {s = 86;}
+
+ else if ( (LA22_66=='f') ) {s = 87;}
+
+ else if ( (LA22_66=='\"') ) {s = 88;}
+
+ else if ( (LA22_66=='\'') ) {s = 89;}
+
+ else if ( (LA22_66=='\\') ) {s = 90;}
+
+ else if ( (LA22_66=='>') ) {s = 91;}
+
+ else if ( (LA22_66=='u') ) {s = 92;}
+
+ else if ( ((LA22_66>='\u0000' && LA22_66<='!')||(LA22_66>='#' && LA22_66<='&')||(LA22_66>='(' && LA22_66<='=')||(LA22_66>='?' && LA22_66<='[')||(LA22_66>=']' && LA22_66<='a')||(LA22_66>='c' && LA22_66<='e')||(LA22_66>='g' && LA22_66<='m')||(LA22_66>='o' && LA22_66<='q')||LA22_66=='s'||(LA22_66>='v' && LA22_66<='\uFFFF')) ) {s = 93;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA22_155 = input.LA(1);
+
+ s = -1;
+ if ( (LA22_155=='\'') ) {s = 95;}
+
+ else if ( ((LA22_155>='\u0000' && LA22_155<='&')||(LA22_155>='(' && LA22_155<='\uFFFF')) ) {s = 94;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 3 :
+ int LA22_92 = input.LA(1);
+
+ s = -1;
+ if ( ((LA22_92>='0' && LA22_92<='9')||(LA22_92>='A' && LA22_92<='F')||(LA22_92>='a' && LA22_92<='f')) ) {s = 111;}
+
+ else if ( (LA22_92=='\'') ) {s = 95;}
+
+ else if ( ((LA22_92>='\u0000' && LA22_92<='&')||(LA22_92>='(' && LA22_92<='/')||(LA22_92>=':' && LA22_92<='@')||(LA22_92>='G' && LA22_92<='`')||(LA22_92>='g' && LA22_92<='\uFFFF')) ) {s = 94;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 4 :
+ int LA22_88 = input.LA(1);
+
+ s = -1;
+ if ( (LA22_88=='\'') ) {s = 95;}
+
+ else if ( ((LA22_88>='\u0000' && LA22_88<='&')||(LA22_88>='(' && LA22_88<='\uFFFF')) ) {s = 94;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 5 :
+ int LA22_89 = input.LA(1);
+
+ s = -1;
+ if ( (LA22_89=='\'') ) {s = 95;}
+
+ else if ( ((LA22_89>='\u0000' && LA22_89<='&')||(LA22_89>='(' && LA22_89<='\uFFFF')) ) {s = 94;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 6 :
+ int LA22_90 = input.LA(1);
+
+ s = -1;
+ if ( ((LA22_90>='\u0000' && LA22_90<='&')||(LA22_90>='(' && LA22_90<='\uFFFF')) ) {s = 94;}
+
+ else if ( (LA22_90=='\'') ) {s = 95;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 7 :
+ int LA22_91 = input.LA(1);
+
+ s = -1;
+ if ( ((LA22_91>='\u0000' && LA22_91<='&')||(LA22_91>='(' && LA22_91<='\uFFFF')) ) {s = 94;}
+
+ else if ( (LA22_91=='\'') ) {s = 95;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 8 :
+ int LA22_93 = input.LA(1);
+
+ s = -1;
+ if ( (LA22_93=='\'') ) {s = 95;}
+
+ else if ( ((LA22_93>='\u0000' && LA22_93<='&')||(LA22_93>='(' && LA22_93<='\uFFFF')) ) {s = 94;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 9 :
+ int LA22_30 = input.LA(1);
+
+ s = -1;
+ if ( (LA22_30=='\\') ) {s = 66;}
+
+ else if ( ((LA22_30>='\u0000' && LA22_30<='&')||(LA22_30>='(' && LA22_30<='[')||(LA22_30>=']' && LA22_30<='\uFFFF')) ) {s = 67;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 10 :
+ int LA22_83 = input.LA(1);
+
+ s = -1;
+ if ( ((LA22_83>='\u0000' && LA22_83<='&')||(LA22_83>='(' && LA22_83<='\uFFFF')) ) {s = 94;}
+
+ else if ( (LA22_83=='\'') ) {s = 95;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 11 :
+ int LA22_85 = input.LA(1);
+
+ s = -1;
+ if ( ((LA22_85>='\u0000' && LA22_85<='&')||(LA22_85>='(' && LA22_85<='\uFFFF')) ) {s = 94;}
+
+ else if ( (LA22_85=='\'') ) {s = 95;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 12 :
+ int LA22_111 = input.LA(1);
+
+ s = -1;
+ if ( ((LA22_111>='\u0000' && LA22_111<='/')||(LA22_111>=':' && LA22_111<='@')||(LA22_111>='G' && LA22_111<='`')||(LA22_111>='g' && LA22_111<='\uFFFF')) ) {s = 94;}
+
+ else if ( ((LA22_111>='0' && LA22_111<='9')||(LA22_111>='A' && LA22_111<='F')||(LA22_111>='a' && LA22_111<='f')) ) {s = 128;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 13 :
+ int LA22_84 = input.LA(1);
+
+ s = -1;
+ if ( (LA22_84=='\'') ) {s = 95;}
+
+ else if ( ((LA22_84>='\u0000' && LA22_84<='&')||(LA22_84>='(' && LA22_84<='\uFFFF')) ) {s = 94;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 14 :
+ int LA22_128 = input.LA(1);
+
+ s = -1;
+ if ( ((LA22_128>='\u0000' && LA22_128<='/')||(LA22_128>=':' && LA22_128<='@')||(LA22_128>='G' && LA22_128<='`')||(LA22_128>='g' && LA22_128<='\uFFFF')) ) {s = 94;}
+
+ else if ( ((LA22_128>='0' && LA22_128<='9')||(LA22_128>='A' && LA22_128<='F')||(LA22_128>='a' && LA22_128<='f')) ) {s = 143;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 15 :
+ int LA22_87 = input.LA(1);
+
+ s = -1;
+ if ( (LA22_87=='\'') ) {s = 95;}
+
+ else if ( ((LA22_87>='\u0000' && LA22_87<='&')||(LA22_87>='(' && LA22_87<='\uFFFF')) ) {s = 94;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 16 :
+ int LA22_143 = input.LA(1);
+
+ s = -1;
+ if ( ((LA22_143>='\u0000' && LA22_143<='/')||(LA22_143>=':' && LA22_143<='@')||(LA22_143>='G' && LA22_143<='`')||(LA22_143>='g' && LA22_143<='\uFFFF')) ) {s = 94;}
+
+ else if ( ((LA22_143>='0' && LA22_143<='9')||(LA22_143>='A' && LA22_143<='F')||(LA22_143>='a' && LA22_143<='f')) ) {s = 155;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 17 :
+ int LA22_86 = input.LA(1);
+
+ s = -1;
+ if ( (LA22_86=='\'') ) {s = 95;}
+
+ else if ( ((LA22_86>='\u0000' && LA22_86<='&')||(LA22_86>='(' && LA22_86<='\uFFFF')) ) {s = 94;}
+
+ if ( s>=0 ) return s;
+ break;
+ }
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 22, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+
+}
\ No newline at end of file
diff --git a/debian/generated-sources/antlr3/org/antlr/grammar/v3/ANTLRv3Parser.java b/debian/generated-sources/antlr3/org/antlr/grammar/v3/ANTLRv3Parser.java
new file mode 100644
index 0000000..c8fed5a
--- /dev/null
+++ b/debian/generated-sources/antlr3/org/antlr/grammar/v3/ANTLRv3Parser.java
@@ -0,0 +1,9447 @@
+// $ANTLR 3.1.3 Mar 17, 2009 19:23:44 org/antlr/grammar/v3/ANTLRv3.g 2010-05-13 00:10:11
+
+ package org.antlr.grammar.v3;
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+
+import org.antlr.runtime.tree.*;
+
+/** ANTLR v3 grammar written in ANTLR v3 with AST construction */
+public class ANTLRv3Parser extends Parser {
+ public static final String[] tokenNames = new String[] {
+ "<invalid>", "<EOR>", "<DOWN>", "<UP>", "DOC_COMMENT", "PARSER", "LEXER", "RULE", "BLOCK", "OPTIONAL", "CLOSURE", "POSITIVE_CLOSURE", "SYNPRED", "RANGE", "CHAR_RANGE", "EPSILON", "ALT", "EOR", "EOB", "EOA", "ID", "ARG", "ARGLIST", "RET", "LEXER_GRAMMAR", "PARSER_GRAMMAR", "TREE_GRAMMAR", "COMBINED_GRAMMAR", "LABEL", "TEMPLATE", "SCOPE", "SEMPRED", "GATED_SEMPRED", "SYN_SEMPRED", "BACKTRACK_SEMPRED", "FRAGMENT", "TREE_BEGIN", "ROOT", "BANG", "REWRITE", "AT", "LABEL_ASSIGN", "LIST_ [...]
+ };
+ public static final int BACKTRACK_SEMPRED=34;
+ public static final int DOUBLE_ANGLE_STRING_LITERAL=53;
+ public static final int LEXER_GRAMMAR=24;
+ public static final int EOA=19;
+ public static final int ARGLIST=22;
+ public static final int EOF=-1;
+ public static final int SEMPRED=31;
+ public static final int ACTION=47;
+ public static final int EOB=18;
+ public static final int TOKEN_REF=44;
+ public static final int T__93=93;
+ public static final int T__91=91;
+ public static final int RET=23;
+ public static final int T__92=92;
+ public static final int STRING_LITERAL=45;
+ public static final int T__90=90;
+ public static final int ARG=21;
+ public static final int EOR=17;
+ public static final int ARG_ACTION=50;
+ public static final int DOUBLE_QUOTE_STRING_LITERAL=52;
+ public static final int NESTED_ARG_ACTION=60;
+ public static final int ACTION_CHAR_LITERAL=62;
+ public static final int T__80=80;
+ public static final int T__81=81;
+ public static final int RULE=7;
+ public static final int T__82=82;
+ public static final int T__83=83;
+ public static final int ACTION_ESC=64;
+ public static final int PARSER_GRAMMAR=25;
+ public static final int SRC=54;
+ public static final int CHAR_RANGE=14;
+ public static final int INT=49;
+ public static final int EPSILON=15;
+ public static final int T__85=85;
+ public static final int T__84=84;
+ public static final int T__87=87;
+ public static final int T__86=86;
+ public static final int T__89=89;
+ public static final int REWRITE=39;
+ public static final int T__88=88;
+ public static final int WS=66;
+ public static final int T__71=71;
+ public static final int T__72=72;
+ public static final int COMBINED_GRAMMAR=27;
+ public static final int T__70=70;
+ public static final int LEXER=6;
+ public static final int SL_COMMENT=55;
+ public static final int TREE_GRAMMAR=26;
+ public static final int T__76=76;
+ public static final int CLOSURE=10;
+ public static final int T__75=75;
+ public static final int PARSER=5;
+ public static final int T__74=74;
+ public static final int T__73=73;
+ public static final int T__79=79;
+ public static final int T__78=78;
+ public static final int T__77=77;
+ public static final int T__68=68;
+ public static final int T__69=69;
+ public static final int T__67=67;
+ public static final int NESTED_ACTION=63;
+ public static final int ESC=58;
+ public static final int FRAGMENT=35;
+ public static final int ID=20;
+ public static final int TREE_BEGIN=36;
+ public static final int AT=40;
+ public static final int ML_COMMENT=56;
+ public static final int ALT=16;
+ public static final int SCOPE=30;
+ public static final int LABEL_ASSIGN=41;
+ public static final int DOC_COMMENT=4;
+ public static final int WS_LOOP=65;
+ public static final int RANGE=13;
+ public static final int TOKENS=43;
+ public static final int GATED_SEMPRED=32;
+ public static final int LITERAL_CHAR=57;
+ public static final int BANG=38;
+ public static final int LIST_LABEL_ASSIGN=42;
+ public static final int ACTION_STRING_LITERAL=61;
+ public static final int ROOT=37;
+ public static final int RULE_REF=51;
+ public static final int SYNPRED=12;
+ public static final int OPTIONAL=9;
+ public static final int CHAR_LITERAL=46;
+ public static final int LABEL=28;
+ public static final int TEMPLATE=29;
+ public static final int SYN_SEMPRED=33;
+ public static final int XDIGIT=59;
+ public static final int BLOCK=8;
+ public static final int POSITIVE_CLOSURE=11;
+ public static final int OPTIONS=48;
+
+ // delegates
+ // delegators
+
+
+ public ANTLRv3Parser(TokenStream input) {
+ this(input, new RecognizerSharedState());
+ }
+ public ANTLRv3Parser(TokenStream input, RecognizerSharedState state) {
+ super(input, state);
+
+ }
+
+ protected TreeAdaptor adaptor = new CommonTreeAdaptor();
+
+ public void setTreeAdaptor(TreeAdaptor adaptor) {
+ this.adaptor = adaptor;
+ }
+ public TreeAdaptor getTreeAdaptor() {
+ return adaptor;
+ }
+
+ public String[] getTokenNames() { return ANTLRv3Parser.tokenNames; }
+ public String getGrammarFileName() { return "org/antlr/grammar/v3/ANTLRv3.g"; }
+
+
+ int gtype;
+
+
+ public static class grammarDef_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "grammarDef"
+ // org/antlr/grammar/v3/ANTLRv3.g:93:1: grammarDef : ( DOC_COMMENT )? ( 'lexer' | 'parser' | 'tree' | ) g= 'grammar' id ';' ( optionsSpec )? ( tokensSpec )? ( attrScope )* ( action )* ( rule )+ EOF -> ^( id ( DOC_COMMENT )? ( optionsSpec )? ( tokensSpec )? ( attrScope )* ( action )* ( rule )+ ) ;
+ public final ANTLRv3Parser.grammarDef_return grammarDef() throws RecognitionException {
+ ANTLRv3Parser.grammarDef_return retval = new ANTLRv3Parser.grammarDef_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token g=null;
+ Token DOC_COMMENT1=null;
+ Token string_literal2=null;
+ Token string_literal3=null;
+ Token string_literal4=null;
+ Token char_literal6=null;
+ Token EOF12=null;
+ ANTLRv3Parser.id_return id5 = null;
+
+ ANTLRv3Parser.optionsSpec_return optionsSpec7 = null;
+
+ ANTLRv3Parser.tokensSpec_return tokensSpec8 = null;
+
+ ANTLRv3Parser.attrScope_return attrScope9 = null;
+
+ ANTLRv3Parser.action_return action10 = null;
+
+ ANTLRv3Parser.rule_return rule11 = null;
+
+
+ CommonTree g_tree=null;
+ CommonTree DOC_COMMENT1_tree=null;
+ CommonTree string_literal2_tree=null;
+ CommonTree string_literal3_tree=null;
+ CommonTree string_literal4_tree=null;
+ CommonTree char_literal6_tree=null;
+ CommonTree EOF12_tree=null;
+ RewriteRuleTokenStream stream_67=new RewriteRuleTokenStream(adaptor,"token 67");
+ RewriteRuleTokenStream stream_DOC_COMMENT=new RewriteRuleTokenStream(adaptor,"token DOC_COMMENT");
+ RewriteRuleTokenStream stream_69=new RewriteRuleTokenStream(adaptor,"token 69");
+ RewriteRuleTokenStream stream_68=new RewriteRuleTokenStream(adaptor,"token 68");
+ RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
+ RewriteRuleTokenStream stream_70=new RewriteRuleTokenStream(adaptor,"token 70");
+ RewriteRuleTokenStream stream_71=new RewriteRuleTokenStream(adaptor,"token 71");
+ RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
+ RewriteRuleSubtreeStream stream_tokensSpec=new RewriteRuleSubtreeStream(adaptor,"rule tokensSpec");
+ RewriteRuleSubtreeStream stream_attrScope=new RewriteRuleSubtreeStream(adaptor,"rule attrScope");
+ RewriteRuleSubtreeStream stream_rule=new RewriteRuleSubtreeStream(adaptor,"rule rule");
+ RewriteRuleSubtreeStream stream_action=new RewriteRuleSubtreeStream(adaptor,"rule action");
+ RewriteRuleSubtreeStream stream_optionsSpec=new RewriteRuleSubtreeStream(adaptor,"rule optionsSpec");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:94:5: ( ( DOC_COMMENT )? ( 'lexer' | 'parser' | 'tree' | ) g= 'grammar' id ';' ( optionsSpec )? ( tokensSpec )? ( attrScope )* ( action )* ( rule )+ EOF -> ^( id ( DOC_COMMENT )? ( optionsSpec )? ( tokensSpec )? ( attrScope )* ( action )* ( rule )+ ) )
+ // org/antlr/grammar/v3/ANTLRv3.g:94:9: ( DOC_COMMENT )? ( 'lexer' | 'parser' | 'tree' | ) g= 'grammar' id ';' ( optionsSpec )? ( tokensSpec )? ( attrScope )* ( action )* ( rule )+ EOF
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:94:9: ( DOC_COMMENT )?
+ int alt1=2;
+ int LA1_0 = input.LA(1);
+
+ if ( (LA1_0==DOC_COMMENT) ) {
+ alt1=1;
+ }
+ switch (alt1) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:94:9: DOC_COMMENT
+ {
+ DOC_COMMENT1=(Token)match(input,DOC_COMMENT,FOLLOW_DOC_COMMENT_in_grammarDef368); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_DOC_COMMENT.add(DOC_COMMENT1);
+
+
+ }
+ break;
+
+ }
+
+ // org/antlr/grammar/v3/ANTLRv3.g:95:6: ( 'lexer' | 'parser' | 'tree' | )
+ int alt2=4;
+ switch ( input.LA(1) ) {
+ case 67:
+ {
+ alt2=1;
+ }
+ break;
+ case 68:
+ {
+ alt2=2;
+ }
+ break;
+ case 69:
+ {
+ alt2=3;
+ }
+ break;
+ case 70:
+ {
+ alt2=4;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 2, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt2) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:95:8: 'lexer'
+ {
+ string_literal2=(Token)match(input,67,FOLLOW_67_in_grammarDef378); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_67.add(string_literal2);
+
+ if ( state.backtracking==0 ) {
+ gtype=LEXER_GRAMMAR;
+ }
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:96:10: 'parser'
+ {
+ string_literal3=(Token)match(input,68,FOLLOW_68_in_grammarDef396); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_68.add(string_literal3);
+
+ if ( state.backtracking==0 ) {
+ gtype=PARSER_GRAMMAR;
+ }
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3.g:97:10: 'tree'
+ {
+ string_literal4=(Token)match(input,69,FOLLOW_69_in_grammarDef412); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_69.add(string_literal4);
+
+ if ( state.backtracking==0 ) {
+ gtype=TREE_GRAMMAR;
+ }
+
+ }
+ break;
+ case 4 :
+ // org/antlr/grammar/v3/ANTLRv3.g:98:14:
+ {
+ if ( state.backtracking==0 ) {
+ gtype=COMBINED_GRAMMAR;
+ }
+
+ }
+ break;
+
+ }
+
+ g=(Token)match(input,70,FOLLOW_70_in_grammarDef453); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_70.add(g);
+
+ pushFollow(FOLLOW_id_in_grammarDef455);
+ id5=id();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_id.add(id5.getTree());
+ char_literal6=(Token)match(input,71,FOLLOW_71_in_grammarDef457); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_71.add(char_literal6);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:100:25: ( optionsSpec )?
+ int alt3=2;
+ int LA3_0 = input.LA(1);
+
+ if ( (LA3_0==OPTIONS) ) {
+ alt3=1;
+ }
+ switch (alt3) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:100:25: optionsSpec
+ {
+ pushFollow(FOLLOW_optionsSpec_in_grammarDef459);
+ optionsSpec7=optionsSpec();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_optionsSpec.add(optionsSpec7.getTree());
+
+ }
+ break;
+
+ }
+
+ // org/antlr/grammar/v3/ANTLRv3.g:100:38: ( tokensSpec )?
+ int alt4=2;
+ int LA4_0 = input.LA(1);
+
+ if ( (LA4_0==TOKENS) ) {
+ alt4=1;
+ }
+ switch (alt4) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:100:38: tokensSpec
+ {
+ pushFollow(FOLLOW_tokensSpec_in_grammarDef462);
+ tokensSpec8=tokensSpec();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_tokensSpec.add(tokensSpec8.getTree());
+
+ }
+ break;
+
+ }
+
+ // org/antlr/grammar/v3/ANTLRv3.g:100:50: ( attrScope )*
+ loop5:
+ do {
+ int alt5=2;
+ int LA5_0 = input.LA(1);
+
+ if ( (LA5_0==SCOPE) ) {
+ alt5=1;
+ }
+
+
+ switch (alt5) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:100:50: attrScope
+ {
+ pushFollow(FOLLOW_attrScope_in_grammarDef465);
+ attrScope9=attrScope();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_attrScope.add(attrScope9.getTree());
+
+ }
+ break;
+
+ default :
+ break loop5;
+ }
+ } while (true);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:100:61: ( action )*
+ loop6:
+ do {
+ int alt6=2;
+ int LA6_0 = input.LA(1);
+
+ if ( (LA6_0==AT) ) {
+ alt6=1;
+ }
+
+
+ switch (alt6) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:100:61: action
+ {
+ pushFollow(FOLLOW_action_in_grammarDef468);
+ action10=action();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_action.add(action10.getTree());
+
+ }
+ break;
+
+ default :
+ break loop6;
+ }
+ } while (true);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:101:6: ( rule )+
+ int cnt7=0;
+ loop7:
+ do {
+ int alt7=2;
+ int LA7_0 = input.LA(1);
+
+ if ( (LA7_0==DOC_COMMENT||LA7_0==FRAGMENT||LA7_0==TOKEN_REF||LA7_0==RULE_REF||(LA7_0>=75 && LA7_0<=77)) ) {
+ alt7=1;
+ }
+
+
+ switch (alt7) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:101:6: rule
+ {
+ pushFollow(FOLLOW_rule_in_grammarDef476);
+ rule11=rule();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_rule.add(rule11.getTree());
+
+ }
+ break;
+
+ default :
+ if ( cnt7 >= 1 ) break loop7;
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ EarlyExitException eee =
+ new EarlyExitException(7, input);
+ throw eee;
+ }
+ cnt7++;
+ } while (true);
+
+ EOF12=(Token)match(input,EOF,FOLLOW_EOF_in_grammarDef484); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_EOF.add(EOF12);
+
+
+
+ // AST REWRITE
+ // elements: optionsSpec, rule, tokensSpec, attrScope, DOC_COMMENT, action, id
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 103:6: -> ^( id ( DOC_COMMENT )? ( optionsSpec )? ( tokensSpec )? ( attrScope )* ( action )* ( rule )+ )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:103:9: ^( id ( DOC_COMMENT )? ( optionsSpec )? ( tokensSpec )? ( attrScope )* ( action )* ( rule )+ )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(adaptor.create(gtype,g), root_1);
+
+ adaptor.addChild(root_1, stream_id.nextTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:104:12: ( DOC_COMMENT )?
+ if ( stream_DOC_COMMENT.hasNext() ) {
+ adaptor.addChild(root_1, stream_DOC_COMMENT.nextNode());
+
+ }
+ stream_DOC_COMMENT.reset();
+ // org/antlr/grammar/v3/ANTLRv3.g:104:25: ( optionsSpec )?
+ if ( stream_optionsSpec.hasNext() ) {
+ adaptor.addChild(root_1, stream_optionsSpec.nextTree());
+
+ }
+ stream_optionsSpec.reset();
+ // org/antlr/grammar/v3/ANTLRv3.g:104:38: ( tokensSpec )?
+ if ( stream_tokensSpec.hasNext() ) {
+ adaptor.addChild(root_1, stream_tokensSpec.nextTree());
+
+ }
+ stream_tokensSpec.reset();
+ // org/antlr/grammar/v3/ANTLRv3.g:104:50: ( attrScope )*
+ while ( stream_attrScope.hasNext() ) {
+ adaptor.addChild(root_1, stream_attrScope.nextTree());
+
+ }
+ stream_attrScope.reset();
+ // org/antlr/grammar/v3/ANTLRv3.g:104:61: ( action )*
+ while ( stream_action.hasNext() ) {
+ adaptor.addChild(root_1, stream_action.nextTree());
+
+ }
+ stream_action.reset();
+ if ( !(stream_rule.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_rule.hasNext() ) {
+ adaptor.addChild(root_1, stream_rule.nextTree());
+
+ }
+ stream_rule.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "grammarDef"
+
+ public static class tokensSpec_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "tokensSpec"
+ // org/antlr/grammar/v3/ANTLRv3.g:108:1: tokensSpec : TOKENS ( tokenSpec )+ '}' -> ^( TOKENS ( tokenSpec )+ ) ;
+ public final ANTLRv3Parser.tokensSpec_return tokensSpec() throws RecognitionException {
+ ANTLRv3Parser.tokensSpec_return retval = new ANTLRv3Parser.tokensSpec_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token TOKENS13=null;
+ Token char_literal15=null;
+ ANTLRv3Parser.tokenSpec_return tokenSpec14 = null;
+
+
+ CommonTree TOKENS13_tree=null;
+ CommonTree char_literal15_tree=null;
+ RewriteRuleTokenStream stream_TOKENS=new RewriteRuleTokenStream(adaptor,"token TOKENS");
+ RewriteRuleTokenStream stream_72=new RewriteRuleTokenStream(adaptor,"token 72");
+ RewriteRuleSubtreeStream stream_tokenSpec=new RewriteRuleSubtreeStream(adaptor,"rule tokenSpec");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:109:2: ( TOKENS ( tokenSpec )+ '}' -> ^( TOKENS ( tokenSpec )+ ) )
+ // org/antlr/grammar/v3/ANTLRv3.g:109:4: TOKENS ( tokenSpec )+ '}'
+ {
+ TOKENS13=(Token)match(input,TOKENS,FOLLOW_TOKENS_in_tokensSpec545); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_TOKENS.add(TOKENS13);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:109:11: ( tokenSpec )+
+ int cnt8=0;
+ loop8:
+ do {
+ int alt8=2;
+ int LA8_0 = input.LA(1);
+
+ if ( (LA8_0==TOKEN_REF) ) {
+ alt8=1;
+ }
+
+
+ switch (alt8) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:109:11: tokenSpec
+ {
+ pushFollow(FOLLOW_tokenSpec_in_tokensSpec547);
+ tokenSpec14=tokenSpec();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_tokenSpec.add(tokenSpec14.getTree());
+
+ }
+ break;
+
+ default :
+ if ( cnt8 >= 1 ) break loop8;
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ EarlyExitException eee =
+ new EarlyExitException(8, input);
+ throw eee;
+ }
+ cnt8++;
+ } while (true);
+
+ char_literal15=(Token)match(input,72,FOLLOW_72_in_tokensSpec550); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_72.add(char_literal15);
+
+
+
+ // AST REWRITE
+ // elements: tokenSpec, TOKENS
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 109:26: -> ^( TOKENS ( tokenSpec )+ )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:109:29: ^( TOKENS ( tokenSpec )+ )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_TOKENS.nextNode(), root_1);
+
+ if ( !(stream_tokenSpec.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_tokenSpec.hasNext() ) {
+ adaptor.addChild(root_1, stream_tokenSpec.nextTree());
+
+ }
+ stream_tokenSpec.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "tokensSpec"
+
+ public static class tokenSpec_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "tokenSpec"
+ // org/antlr/grammar/v3/ANTLRv3.g:112:1: tokenSpec : TOKEN_REF ( '=' (lit= STRING_LITERAL | lit= CHAR_LITERAL ) -> ^( '=' TOKEN_REF $lit) | -> TOKEN_REF ) ';' ;
+ public final ANTLRv3Parser.tokenSpec_return tokenSpec() throws RecognitionException {
+ ANTLRv3Parser.tokenSpec_return retval = new ANTLRv3Parser.tokenSpec_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token lit=null;
+ Token TOKEN_REF16=null;
+ Token char_literal17=null;
+ Token char_literal18=null;
+
+ CommonTree lit_tree=null;
+ CommonTree TOKEN_REF16_tree=null;
+ CommonTree char_literal17_tree=null;
+ CommonTree char_literal18_tree=null;
+ RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL");
+ RewriteRuleTokenStream stream_CHAR_LITERAL=new RewriteRuleTokenStream(adaptor,"token CHAR_LITERAL");
+ RewriteRuleTokenStream stream_LABEL_ASSIGN=new RewriteRuleTokenStream(adaptor,"token LABEL_ASSIGN");
+ RewriteRuleTokenStream stream_71=new RewriteRuleTokenStream(adaptor,"token 71");
+ RewriteRuleTokenStream stream_TOKEN_REF=new RewriteRuleTokenStream(adaptor,"token TOKEN_REF");
+
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:113:2: ( TOKEN_REF ( '=' (lit= STRING_LITERAL | lit= CHAR_LITERAL ) -> ^( '=' TOKEN_REF $lit) | -> TOKEN_REF ) ';' )
+ // org/antlr/grammar/v3/ANTLRv3.g:113:4: TOKEN_REF ( '=' (lit= STRING_LITERAL | lit= CHAR_LITERAL ) -> ^( '=' TOKEN_REF $lit) | -> TOKEN_REF ) ';'
+ {
+ TOKEN_REF16=(Token)match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_tokenSpec570); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_TOKEN_REF.add(TOKEN_REF16);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:114:3: ( '=' (lit= STRING_LITERAL | lit= CHAR_LITERAL ) -> ^( '=' TOKEN_REF $lit) | -> TOKEN_REF )
+ int alt10=2;
+ int LA10_0 = input.LA(1);
+
+ if ( (LA10_0==LABEL_ASSIGN) ) {
+ alt10=1;
+ }
+ else if ( (LA10_0==71) ) {
+ alt10=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 10, 0, input);
+
+ throw nvae;
+ }
+ switch (alt10) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:114:5: '=' (lit= STRING_LITERAL | lit= CHAR_LITERAL )
+ {
+ char_literal17=(Token)match(input,LABEL_ASSIGN,FOLLOW_LABEL_ASSIGN_in_tokenSpec576); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_LABEL_ASSIGN.add(char_literal17);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:114:9: (lit= STRING_LITERAL | lit= CHAR_LITERAL )
+ int alt9=2;
+ int LA9_0 = input.LA(1);
+
+ if ( (LA9_0==STRING_LITERAL) ) {
+ alt9=1;
+ }
+ else if ( (LA9_0==CHAR_LITERAL) ) {
+ alt9=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 9, 0, input);
+
+ throw nvae;
+ }
+ switch (alt9) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:114:10: lit= STRING_LITERAL
+ {
+ lit=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_tokenSpec581); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_STRING_LITERAL.add(lit);
+
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:114:29: lit= CHAR_LITERAL
+ {
+ lit=(Token)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_tokenSpec585); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_CHAR_LITERAL.add(lit);
+
+
+ }
+ break;
+
+ }
+
+
+
+ // AST REWRITE
+ // elements: TOKEN_REF, LABEL_ASSIGN, lit
+ // token labels: lit
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleTokenStream stream_lit=new RewriteRuleTokenStream(adaptor,"token lit",lit);
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 114:47: -> ^( '=' TOKEN_REF $lit)
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:114:50: ^( '=' TOKEN_REF $lit)
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_LABEL_ASSIGN.nextNode(), root_1);
+
+ adaptor.addChild(root_1, stream_TOKEN_REF.nextNode());
+ adaptor.addChild(root_1, stream_lit.nextNode());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:115:16:
+ {
+
+ // AST REWRITE
+ // elements: TOKEN_REF
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 115:16: -> TOKEN_REF
+ {
+ adaptor.addChild(root_0, stream_TOKEN_REF.nextNode());
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+
+ }
+
+ char_literal18=(Token)match(input,71,FOLLOW_71_in_tokenSpec624); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_71.add(char_literal18);
+
+
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "tokenSpec"
+
+ public static class attrScope_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "attrScope"
+ // org/antlr/grammar/v3/ANTLRv3.g:120:1: attrScope : 'scope' id ACTION -> ^( 'scope' id ACTION ) ;
+ public final ANTLRv3Parser.attrScope_return attrScope() throws RecognitionException {
+ ANTLRv3Parser.attrScope_return retval = new ANTLRv3Parser.attrScope_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token string_literal19=null;
+ Token ACTION21=null;
+ ANTLRv3Parser.id_return id20 = null;
+
+
+ CommonTree string_literal19_tree=null;
+ CommonTree ACTION21_tree=null;
+ RewriteRuleTokenStream stream_SCOPE=new RewriteRuleTokenStream(adaptor,"token SCOPE");
+ RewriteRuleTokenStream stream_ACTION=new RewriteRuleTokenStream(adaptor,"token ACTION");
+ RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:121:2: ( 'scope' id ACTION -> ^( 'scope' id ACTION ) )
+ // org/antlr/grammar/v3/ANTLRv3.g:121:4: 'scope' id ACTION
+ {
+ string_literal19=(Token)match(input,SCOPE,FOLLOW_SCOPE_in_attrScope635); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_SCOPE.add(string_literal19);
+
+ pushFollow(FOLLOW_id_in_attrScope637);
+ id20=id();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_id.add(id20.getTree());
+ ACTION21=(Token)match(input,ACTION,FOLLOW_ACTION_in_attrScope639); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ACTION.add(ACTION21);
+
+
+
+ // AST REWRITE
+ // elements: SCOPE, ACTION, id
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 121:22: -> ^( 'scope' id ACTION )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:121:25: ^( 'scope' id ACTION )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_SCOPE.nextNode(), root_1);
+
+ adaptor.addChild(root_1, stream_id.nextTree());
+ adaptor.addChild(root_1, stream_ACTION.nextNode());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "attrScope"
+
+ public static class action_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "action"
+ // org/antlr/grammar/v3/ANTLRv3.g:124:1: action : '@' ( actionScopeName '::' )? id ACTION -> ^( '@' ( actionScopeName )? id ACTION ) ;
+ public final ANTLRv3Parser.action_return action() throws RecognitionException {
+ ANTLRv3Parser.action_return retval = new ANTLRv3Parser.action_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token char_literal22=null;
+ Token string_literal24=null;
+ Token ACTION26=null;
+ ANTLRv3Parser.actionScopeName_return actionScopeName23 = null;
+
+ ANTLRv3Parser.id_return id25 = null;
+
+
+ CommonTree char_literal22_tree=null;
+ CommonTree string_literal24_tree=null;
+ CommonTree ACTION26_tree=null;
+ RewriteRuleTokenStream stream_AT=new RewriteRuleTokenStream(adaptor,"token AT");
+ RewriteRuleTokenStream stream_ACTION=new RewriteRuleTokenStream(adaptor,"token ACTION");
+ RewriteRuleTokenStream stream_73=new RewriteRuleTokenStream(adaptor,"token 73");
+ RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
+ RewriteRuleSubtreeStream stream_actionScopeName=new RewriteRuleSubtreeStream(adaptor,"rule actionScopeName");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:126:2: ( '@' ( actionScopeName '::' )? id ACTION -> ^( '@' ( actionScopeName )? id ACTION ) )
+ // org/antlr/grammar/v3/ANTLRv3.g:126:4: '@' ( actionScopeName '::' )? id ACTION
+ {
+ char_literal22=(Token)match(input,AT,FOLLOW_AT_in_action662); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_AT.add(char_literal22);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:126:8: ( actionScopeName '::' )?
+ int alt11=2;
+ switch ( input.LA(1) ) {
+ case TOKEN_REF:
+ {
+ int LA11_1 = input.LA(2);
+
+ if ( (LA11_1==73) ) {
+ alt11=1;
+ }
+ }
+ break;
+ case RULE_REF:
+ {
+ int LA11_2 = input.LA(2);
+
+ if ( (LA11_2==73) ) {
+ alt11=1;
+ }
+ }
+ break;
+ case 67:
+ case 68:
+ {
+ alt11=1;
+ }
+ break;
+ }
+
+ switch (alt11) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:126:9: actionScopeName '::'
+ {
+ pushFollow(FOLLOW_actionScopeName_in_action665);
+ actionScopeName23=actionScopeName();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_actionScopeName.add(actionScopeName23.getTree());
+ string_literal24=(Token)match(input,73,FOLLOW_73_in_action667); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_73.add(string_literal24);
+
+
+ }
+ break;
+
+ }
+
+ pushFollow(FOLLOW_id_in_action671);
+ id25=id();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_id.add(id25.getTree());
+ ACTION26=(Token)match(input,ACTION,FOLLOW_ACTION_in_action673); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ACTION.add(ACTION26);
+
+
+
+ // AST REWRITE
+ // elements: id, AT, ACTION, actionScopeName
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 126:42: -> ^( '@' ( actionScopeName )? id ACTION )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:126:45: ^( '@' ( actionScopeName )? id ACTION )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_AT.nextNode(), root_1);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:126:51: ( actionScopeName )?
+ if ( stream_actionScopeName.hasNext() ) {
+ adaptor.addChild(root_1, stream_actionScopeName.nextTree());
+
+ }
+ stream_actionScopeName.reset();
+ adaptor.addChild(root_1, stream_id.nextTree());
+ adaptor.addChild(root_1, stream_ACTION.nextNode());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "action"
+
+ public static class actionScopeName_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "actionScopeName"
+ // org/antlr/grammar/v3/ANTLRv3.g:129:1: actionScopeName : ( id | l= 'lexer' -> ID[$l] | p= 'parser' -> ID[$p] );
+ public final ANTLRv3Parser.actionScopeName_return actionScopeName() throws RecognitionException {
+ ANTLRv3Parser.actionScopeName_return retval = new ANTLRv3Parser.actionScopeName_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token l=null;
+ Token p=null;
+ ANTLRv3Parser.id_return id27 = null;
+
+
+ CommonTree l_tree=null;
+ CommonTree p_tree=null;
+ RewriteRuleTokenStream stream_67=new RewriteRuleTokenStream(adaptor,"token 67");
+ RewriteRuleTokenStream stream_68=new RewriteRuleTokenStream(adaptor,"token 68");
+
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:133:2: ( id | l= 'lexer' -> ID[$l] | p= 'parser' -> ID[$p] )
+ int alt12=3;
+ switch ( input.LA(1) ) {
+ case TOKEN_REF:
+ case RULE_REF:
+ {
+ alt12=1;
+ }
+ break;
+ case 67:
+ {
+ alt12=2;
+ }
+ break;
+ case 68:
+ {
+ alt12=3;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 12, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt12) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:133:4: id
+ {
+ root_0 = (CommonTree)adaptor.nil();
+
+ pushFollow(FOLLOW_id_in_actionScopeName699);
+ id27=id();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) adaptor.addChild(root_0, id27.getTree());
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:134:4: l= 'lexer'
+ {
+ l=(Token)match(input,67,FOLLOW_67_in_actionScopeName706); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_67.add(l);
+
+
+
+ // AST REWRITE
+ // elements:
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 134:14: -> ID[$l]
+ {
+ adaptor.addChild(root_0, (CommonTree)adaptor.create(ID, l));
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3.g:135:9: p= 'parser'
+ {
+ p=(Token)match(input,68,FOLLOW_68_in_actionScopeName723); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_68.add(p);
+
+
+
+ // AST REWRITE
+ // elements:
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 135:20: -> ID[$p]
+ {
+ adaptor.addChild(root_0, (CommonTree)adaptor.create(ID, p));
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+
+ }
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "actionScopeName"
+
+ public static class optionsSpec_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "optionsSpec"
+ // org/antlr/grammar/v3/ANTLRv3.g:138:1: optionsSpec : OPTIONS ( option ';' )+ '}' -> ^( OPTIONS ( option )+ ) ;
+ public final ANTLRv3Parser.optionsSpec_return optionsSpec() throws RecognitionException {
+ ANTLRv3Parser.optionsSpec_return retval = new ANTLRv3Parser.optionsSpec_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token OPTIONS28=null;
+ Token char_literal30=null;
+ Token char_literal31=null;
+ ANTLRv3Parser.option_return option29 = null;
+
+
+ CommonTree OPTIONS28_tree=null;
+ CommonTree char_literal30_tree=null;
+ CommonTree char_literal31_tree=null;
+ RewriteRuleTokenStream stream_71=new RewriteRuleTokenStream(adaptor,"token 71");
+ RewriteRuleTokenStream stream_72=new RewriteRuleTokenStream(adaptor,"token 72");
+ RewriteRuleTokenStream stream_OPTIONS=new RewriteRuleTokenStream(adaptor,"token OPTIONS");
+ RewriteRuleSubtreeStream stream_option=new RewriteRuleSubtreeStream(adaptor,"rule option");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:139:2: ( OPTIONS ( option ';' )+ '}' -> ^( OPTIONS ( option )+ ) )
+ // org/antlr/grammar/v3/ANTLRv3.g:139:4: OPTIONS ( option ';' )+ '}'
+ {
+ OPTIONS28=(Token)match(input,OPTIONS,FOLLOW_OPTIONS_in_optionsSpec739); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_OPTIONS.add(OPTIONS28);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:139:12: ( option ';' )+
+ int cnt13=0;
+ loop13:
+ do {
+ int alt13=2;
+ int LA13_0 = input.LA(1);
+
+ if ( (LA13_0==TOKEN_REF||LA13_0==RULE_REF) ) {
+ alt13=1;
+ }
+
+
+ switch (alt13) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:139:13: option ';'
+ {
+ pushFollow(FOLLOW_option_in_optionsSpec742);
+ option29=option();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_option.add(option29.getTree());
+ char_literal30=(Token)match(input,71,FOLLOW_71_in_optionsSpec744); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_71.add(char_literal30);
+
+
+ }
+ break;
+
+ default :
+ if ( cnt13 >= 1 ) break loop13;
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ EarlyExitException eee =
+ new EarlyExitException(13, input);
+ throw eee;
+ }
+ cnt13++;
+ } while (true);
+
+ char_literal31=(Token)match(input,72,FOLLOW_72_in_optionsSpec748); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_72.add(char_literal31);
+
+
+
+ // AST REWRITE
+ // elements: OPTIONS, option
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 139:30: -> ^( OPTIONS ( option )+ )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:139:33: ^( OPTIONS ( option )+ )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_OPTIONS.nextNode(), root_1);
+
+ if ( !(stream_option.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_option.hasNext() ) {
+ adaptor.addChild(root_1, stream_option.nextTree());
+
+ }
+ stream_option.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "optionsSpec"
+
+ public static class option_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "option"
+ // org/antlr/grammar/v3/ANTLRv3.g:142:1: option : id '=' optionValue -> ^( '=' id optionValue ) ;
+ public final ANTLRv3Parser.option_return option() throws RecognitionException {
+ ANTLRv3Parser.option_return retval = new ANTLRv3Parser.option_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token char_literal33=null;
+ ANTLRv3Parser.id_return id32 = null;
+
+ ANTLRv3Parser.optionValue_return optionValue34 = null;
+
+
+ CommonTree char_literal33_tree=null;
+ RewriteRuleTokenStream stream_LABEL_ASSIGN=new RewriteRuleTokenStream(adaptor,"token LABEL_ASSIGN");
+ RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
+ RewriteRuleSubtreeStream stream_optionValue=new RewriteRuleSubtreeStream(adaptor,"rule optionValue");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:143:5: ( id '=' optionValue -> ^( '=' id optionValue ) )
+ // org/antlr/grammar/v3/ANTLRv3.g:143:9: id '=' optionValue
+ {
+ pushFollow(FOLLOW_id_in_option773);
+ id32=id();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_id.add(id32.getTree());
+ char_literal33=(Token)match(input,LABEL_ASSIGN,FOLLOW_LABEL_ASSIGN_in_option775); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_LABEL_ASSIGN.add(char_literal33);
+
+ pushFollow(FOLLOW_optionValue_in_option777);
+ optionValue34=optionValue();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_optionValue.add(optionValue34.getTree());
+
+
+ // AST REWRITE
+ // elements: optionValue, LABEL_ASSIGN, id
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 143:28: -> ^( '=' id optionValue )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:143:31: ^( '=' id optionValue )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_LABEL_ASSIGN.nextNode(), root_1);
+
+ adaptor.addChild(root_1, stream_id.nextTree());
+ adaptor.addChild(root_1, stream_optionValue.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "option"
+
+ public static class optionValue_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "optionValue"
+ // org/antlr/grammar/v3/ANTLRv3.g:146:1: optionValue : ( qid | STRING_LITERAL | CHAR_LITERAL | INT | s= '*' -> STRING_LITERAL[$s] );
+ public final ANTLRv3Parser.optionValue_return optionValue() throws RecognitionException {
+ ANTLRv3Parser.optionValue_return retval = new ANTLRv3Parser.optionValue_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token s=null;
+ Token STRING_LITERAL36=null;
+ Token CHAR_LITERAL37=null;
+ Token INT38=null;
+ ANTLRv3Parser.qid_return qid35 = null;
+
+
+ CommonTree s_tree=null;
+ CommonTree STRING_LITERAL36_tree=null;
+ CommonTree CHAR_LITERAL37_tree=null;
+ CommonTree INT38_tree=null;
+ RewriteRuleTokenStream stream_74=new RewriteRuleTokenStream(adaptor,"token 74");
+
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:147:5: ( qid | STRING_LITERAL | CHAR_LITERAL | INT | s= '*' -> STRING_LITERAL[$s] )
+ int alt14=5;
+ switch ( input.LA(1) ) {
+ case TOKEN_REF:
+ case RULE_REF:
+ {
+ alt14=1;
+ }
+ break;
+ case STRING_LITERAL:
+ {
+ alt14=2;
+ }
+ break;
+ case CHAR_LITERAL:
+ {
+ alt14=3;
+ }
+ break;
+ case INT:
+ {
+ alt14=4;
+ }
+ break;
+ case 74:
+ {
+ alt14=5;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 14, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt14) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:147:9: qid
+ {
+ root_0 = (CommonTree)adaptor.nil();
+
+ pushFollow(FOLLOW_qid_in_optionValue806);
+ qid35=qid();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) adaptor.addChild(root_0, qid35.getTree());
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:148:9: STRING_LITERAL
+ {
+ root_0 = (CommonTree)adaptor.nil();
+
+ STRING_LITERAL36=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_optionValue816); if (state.failed) return retval;
+ if ( state.backtracking==0 ) {
+ STRING_LITERAL36_tree = (CommonTree)adaptor.create(STRING_LITERAL36);
+ adaptor.addChild(root_0, STRING_LITERAL36_tree);
+ }
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3.g:149:9: CHAR_LITERAL
+ {
+ root_0 = (CommonTree)adaptor.nil();
+
+ CHAR_LITERAL37=(Token)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_optionValue826); if (state.failed) return retval;
+ if ( state.backtracking==0 ) {
+ CHAR_LITERAL37_tree = (CommonTree)adaptor.create(CHAR_LITERAL37);
+ adaptor.addChild(root_0, CHAR_LITERAL37_tree);
+ }
+
+ }
+ break;
+ case 4 :
+ // org/antlr/grammar/v3/ANTLRv3.g:150:9: INT
+ {
+ root_0 = (CommonTree)adaptor.nil();
+
+ INT38=(Token)match(input,INT,FOLLOW_INT_in_optionValue836); if (state.failed) return retval;
+ if ( state.backtracking==0 ) {
+ INT38_tree = (CommonTree)adaptor.create(INT38);
+ adaptor.addChild(root_0, INT38_tree);
+ }
+
+ }
+ break;
+ case 5 :
+ // org/antlr/grammar/v3/ANTLRv3.g:151:7: s= '*'
+ {
+ s=(Token)match(input,74,FOLLOW_74_in_optionValue846); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_74.add(s);
+
+
+
+ // AST REWRITE
+ // elements:
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 151:13: -> STRING_LITERAL[$s]
+ {
+ adaptor.addChild(root_0, (CommonTree)adaptor.create(STRING_LITERAL, s));
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+
+ }
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "optionValue"
+
+ protected static class rule_scope {
+ String name;
+ }
+ protected Stack rule_stack = new Stack();
+
+ public static class rule_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "rule"
+ // org/antlr/grammar/v3/ANTLRv3.g:154:1: rule : ( DOC_COMMENT )? (modifier= ( 'protected' | 'public' | 'private' | 'fragment' ) )? id ( '!' )? (arg= ARG_ACTION )? ( 'returns' rt= ARG_ACTION )? ( throwsSpec )? ( optionsSpec )? ( ruleScopeSpec )? ( ruleAction )* ':' altList ';' ( exceptionGroup )? -> ^( RULE id ( ^( ARG[$arg] $arg) )? ( ^( 'returns' $rt) )? ( throwsSpec )? ( optionsSpec )? ( ruleScopeSpec )? ( ruleAction )* altList ( exceptionGroup )? EOR[\"EOR\"] ) ;
+ public final ANTLRv3Parser.rule_return rule() throws RecognitionException {
+ rule_stack.push(new rule_scope());
+ ANTLRv3Parser.rule_return retval = new ANTLRv3Parser.rule_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token modifier=null;
+ Token arg=null;
+ Token rt=null;
+ Token DOC_COMMENT39=null;
+ Token string_literal40=null;
+ Token string_literal41=null;
+ Token string_literal42=null;
+ Token string_literal43=null;
+ Token char_literal45=null;
+ Token string_literal46=null;
+ Token char_literal51=null;
+ Token char_literal53=null;
+ ANTLRv3Parser.id_return id44 = null;
+
+ ANTLRv3Parser.throwsSpec_return throwsSpec47 = null;
+
+ ANTLRv3Parser.optionsSpec_return optionsSpec48 = null;
+
+ ANTLRv3Parser.ruleScopeSpec_return ruleScopeSpec49 = null;
+
+ ANTLRv3Parser.ruleAction_return ruleAction50 = null;
+
+ ANTLRv3Parser.altList_return altList52 = null;
+
+ ANTLRv3Parser.exceptionGroup_return exceptionGroup54 = null;
+
+
+ CommonTree modifier_tree=null;
+ CommonTree arg_tree=null;
+ CommonTree rt_tree=null;
+ CommonTree DOC_COMMENT39_tree=null;
+ CommonTree string_literal40_tree=null;
+ CommonTree string_literal41_tree=null;
+ CommonTree string_literal42_tree=null;
+ CommonTree string_literal43_tree=null;
+ CommonTree char_literal45_tree=null;
+ CommonTree string_literal46_tree=null;
+ CommonTree char_literal51_tree=null;
+ CommonTree char_literal53_tree=null;
+ RewriteRuleTokenStream stream_DOC_COMMENT=new RewriteRuleTokenStream(adaptor,"token DOC_COMMENT");
+ RewriteRuleTokenStream stream_78=new RewriteRuleTokenStream(adaptor,"token 78");
+ RewriteRuleTokenStream stream_RET=new RewriteRuleTokenStream(adaptor,"token RET");
+ RewriteRuleTokenStream stream_77=new RewriteRuleTokenStream(adaptor,"token 77");
+ RewriteRuleTokenStream stream_BANG=new RewriteRuleTokenStream(adaptor,"token BANG");
+ RewriteRuleTokenStream stream_71=new RewriteRuleTokenStream(adaptor,"token 71");
+ RewriteRuleTokenStream stream_FRAGMENT=new RewriteRuleTokenStream(adaptor,"token FRAGMENT");
+ RewriteRuleTokenStream stream_75=new RewriteRuleTokenStream(adaptor,"token 75");
+ RewriteRuleTokenStream stream_ARG_ACTION=new RewriteRuleTokenStream(adaptor,"token ARG_ACTION");
+ RewriteRuleTokenStream stream_76=new RewriteRuleTokenStream(adaptor,"token 76");
+ RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
+ RewriteRuleSubtreeStream stream_exceptionGroup=new RewriteRuleSubtreeStream(adaptor,"rule exceptionGroup");
+ RewriteRuleSubtreeStream stream_throwsSpec=new RewriteRuleSubtreeStream(adaptor,"rule throwsSpec");
+ RewriteRuleSubtreeStream stream_ruleScopeSpec=new RewriteRuleSubtreeStream(adaptor,"rule ruleScopeSpec");
+ RewriteRuleSubtreeStream stream_optionsSpec=new RewriteRuleSubtreeStream(adaptor,"rule optionsSpec");
+ RewriteRuleSubtreeStream stream_altList=new RewriteRuleSubtreeStream(adaptor,"rule altList");
+ RewriteRuleSubtreeStream stream_ruleAction=new RewriteRuleSubtreeStream(adaptor,"rule ruleAction");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:158:2: ( ( DOC_COMMENT )? (modifier= ( 'protected' | 'public' | 'private' | 'fragment' ) )? id ( '!' )? (arg= ARG_ACTION )? ( 'returns' rt= ARG_ACTION )? ( throwsSpec )? ( optionsSpec )? ( ruleScopeSpec )? ( ruleAction )* ':' altList ';' ( exceptionGroup )? -> ^( RULE id ( ^( ARG[$arg] $arg) )? ( ^( 'returns' $rt) )? ( throwsSpec )? ( optionsSpec )? ( ruleScopeSpec )? ( ruleAction )* altList ( exceptionGroup )? EOR[\"EOR\"] ) )
+ // org/antlr/grammar/v3/ANTLRv3.g:158:4: ( DOC_COMMENT )? (modifier= ( 'protected' | 'public' | 'private' | 'fragment' ) )? id ( '!' )? (arg= ARG_ACTION )? ( 'returns' rt= ARG_ACTION )? ( throwsSpec )? ( optionsSpec )? ( ruleScopeSpec )? ( ruleAction )* ':' altList ';' ( exceptionGroup )?
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:158:4: ( DOC_COMMENT )?
+ int alt15=2;
+ int LA15_0 = input.LA(1);
+
+ if ( (LA15_0==DOC_COMMENT) ) {
+ alt15=1;
+ }
+ switch (alt15) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:158:4: DOC_COMMENT
+ {
+ DOC_COMMENT39=(Token)match(input,DOC_COMMENT,FOLLOW_DOC_COMMENT_in_rule871); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_DOC_COMMENT.add(DOC_COMMENT39);
+
+
+ }
+ break;
+
+ }
+
+ // org/antlr/grammar/v3/ANTLRv3.g:159:3: (modifier= ( 'protected' | 'public' | 'private' | 'fragment' ) )?
+ int alt17=2;
+ int LA17_0 = input.LA(1);
+
+ if ( (LA17_0==FRAGMENT||(LA17_0>=75 && LA17_0<=77)) ) {
+ alt17=1;
+ }
+ switch (alt17) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:159:5: modifier= ( 'protected' | 'public' | 'private' | 'fragment' )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:159:14: ( 'protected' | 'public' | 'private' | 'fragment' )
+ int alt16=4;
+ switch ( input.LA(1) ) {
+ case 75:
+ {
+ alt16=1;
+ }
+ break;
+ case 76:
+ {
+ alt16=2;
+ }
+ break;
+ case 77:
+ {
+ alt16=3;
+ }
+ break;
+ case FRAGMENT:
+ {
+ alt16=4;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 16, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt16) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:159:15: 'protected'
+ {
+ string_literal40=(Token)match(input,75,FOLLOW_75_in_rule881); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_75.add(string_literal40);
+
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:159:27: 'public'
+ {
+ string_literal41=(Token)match(input,76,FOLLOW_76_in_rule883); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_76.add(string_literal41);
+
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3.g:159:36: 'private'
+ {
+ string_literal42=(Token)match(input,77,FOLLOW_77_in_rule885); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_77.add(string_literal42);
+
+
+ }
+ break;
+ case 4 :
+ // org/antlr/grammar/v3/ANTLRv3.g:159:46: 'fragment'
+ {
+ string_literal43=(Token)match(input,FRAGMENT,FOLLOW_FRAGMENT_in_rule887); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_FRAGMENT.add(string_literal43);
+
+
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ pushFollow(FOLLOW_id_in_rule895);
+ id44=id();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_id.add(id44.getTree());
+ if ( state.backtracking==0 ) {
+ ((rule_scope)rule_stack.peek()).name = (id44!=null?input.toString(id44.start,id44.stop):null);
+ }
+ // org/antlr/grammar/v3/ANTLRv3.g:161:3: ( '!' )?
+ int alt18=2;
+ int LA18_0 = input.LA(1);
+
+ if ( (LA18_0==BANG) ) {
+ alt18=1;
+ }
+ switch (alt18) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:161:3: '!'
+ {
+ char_literal45=(Token)match(input,BANG,FOLLOW_BANG_in_rule901); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_BANG.add(char_literal45);
+
+
+ }
+ break;
+
+ }
+
+ // org/antlr/grammar/v3/ANTLRv3.g:162:3: (arg= ARG_ACTION )?
+ int alt19=2;
+ int LA19_0 = input.LA(1);
+
+ if ( (LA19_0==ARG_ACTION) ) {
+ alt19=1;
+ }
+ switch (alt19) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:162:5: arg= ARG_ACTION
+ {
+ arg=(Token)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_rule910); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ARG_ACTION.add(arg);
+
+
+ }
+ break;
+
+ }
+
+ // org/antlr/grammar/v3/ANTLRv3.g:163:3: ( 'returns' rt= ARG_ACTION )?
+ int alt20=2;
+ int LA20_0 = input.LA(1);
+
+ if ( (LA20_0==RET) ) {
+ alt20=1;
+ }
+ switch (alt20) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:163:5: 'returns' rt= ARG_ACTION
+ {
+ string_literal46=(Token)match(input,RET,FOLLOW_RET_in_rule919); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_RET.add(string_literal46);
+
+ rt=(Token)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_rule923); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ARG_ACTION.add(rt);
+
+
+ }
+ break;
+
+ }
+
+ // org/antlr/grammar/v3/ANTLRv3.g:164:3: ( throwsSpec )?
+ int alt21=2;
+ int LA21_0 = input.LA(1);
+
+ if ( (LA21_0==79) ) {
+ alt21=1;
+ }
+ switch (alt21) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:164:3: throwsSpec
+ {
+ pushFollow(FOLLOW_throwsSpec_in_rule931);
+ throwsSpec47=throwsSpec();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_throwsSpec.add(throwsSpec47.getTree());
+
+ }
+ break;
+
+ }
+
+ // org/antlr/grammar/v3/ANTLRv3.g:164:15: ( optionsSpec )?
+ int alt22=2;
+ int LA22_0 = input.LA(1);
+
+ if ( (LA22_0==OPTIONS) ) {
+ alt22=1;
+ }
+ switch (alt22) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:164:15: optionsSpec
+ {
+ pushFollow(FOLLOW_optionsSpec_in_rule934);
+ optionsSpec48=optionsSpec();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_optionsSpec.add(optionsSpec48.getTree());
+
+ }
+ break;
+
+ }
+
+ // org/antlr/grammar/v3/ANTLRv3.g:164:28: ( ruleScopeSpec )?
+ int alt23=2;
+ int LA23_0 = input.LA(1);
+
+ if ( (LA23_0==SCOPE) ) {
+ alt23=1;
+ }
+ switch (alt23) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:164:28: ruleScopeSpec
+ {
+ pushFollow(FOLLOW_ruleScopeSpec_in_rule937);
+ ruleScopeSpec49=ruleScopeSpec();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ruleScopeSpec.add(ruleScopeSpec49.getTree());
+
+ }
+ break;
+
+ }
+
+ // org/antlr/grammar/v3/ANTLRv3.g:164:43: ( ruleAction )*
+ loop24:
+ do {
+ int alt24=2;
+ int LA24_0 = input.LA(1);
+
+ if ( (LA24_0==AT) ) {
+ alt24=1;
+ }
+
+
+ switch (alt24) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:164:43: ruleAction
+ {
+ pushFollow(FOLLOW_ruleAction_in_rule940);
+ ruleAction50=ruleAction();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ruleAction.add(ruleAction50.getTree());
+
+ }
+ break;
+
+ default :
+ break loop24;
+ }
+ } while (true);
+
+ char_literal51=(Token)match(input,78,FOLLOW_78_in_rule945); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_78.add(char_literal51);
+
+ pushFollow(FOLLOW_altList_in_rule947);
+ altList52=altList();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_altList.add(altList52.getTree());
+ char_literal53=(Token)match(input,71,FOLLOW_71_in_rule949); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_71.add(char_literal53);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:166:3: ( exceptionGroup )?
+ int alt25=2;
+ int LA25_0 = input.LA(1);
+
+ if ( ((LA25_0>=84 && LA25_0<=85)) ) {
+ alt25=1;
+ }
+ switch (alt25) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:166:3: exceptionGroup
+ {
+ pushFollow(FOLLOW_exceptionGroup_in_rule953);
+ exceptionGroup54=exceptionGroup();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_exceptionGroup.add(exceptionGroup54.getTree());
+
+ }
+ break;
+
+ }
+
+
+
+ // AST REWRITE
+ // elements: altList, exceptionGroup, rt, RET, arg, id, ruleScopeSpec, ruleAction, optionsSpec, throwsSpec
+ // token labels: arg, rt
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleTokenStream stream_arg=new RewriteRuleTokenStream(adaptor,"token arg",arg);
+ RewriteRuleTokenStream stream_rt=new RewriteRuleTokenStream(adaptor,"token rt",rt);
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 167:6: -> ^( RULE id ( ^( ARG[$arg] $arg) )? ( ^( 'returns' $rt) )? ( throwsSpec )? ( optionsSpec )? ( ruleScopeSpec )? ( ruleAction )* altList ( exceptionGroup )? EOR[\"EOR\"] )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:167:9: ^( RULE id ( ^( ARG[$arg] $arg) )? ( ^( 'returns' $rt) )? ( throwsSpec )? ( optionsSpec )? ( ruleScopeSpec )? ( ruleAction )* altList ( exceptionGroup )? EOR[\"EOR\"] )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(RULE, "RULE"), root_1);
+
+ adaptor.addChild(root_1, stream_id.nextTree());
+ adaptor.addChild(root_1, modifier!=null?adaptor.create(modifier):null);
+ // org/antlr/grammar/v3/ANTLRv3.g:167:67: ( ^( ARG[$arg] $arg) )?
+ if ( stream_arg.hasNext() ) {
+ // org/antlr/grammar/v3/ANTLRv3.g:167:67: ^( ARG[$arg] $arg)
+ {
+ CommonTree root_2 = (CommonTree)adaptor.nil();
+ root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ARG, arg), root_2);
+
+ adaptor.addChild(root_2, stream_arg.nextNode());
+
+ adaptor.addChild(root_1, root_2);
+ }
+
+ }
+ stream_arg.reset();
+ // org/antlr/grammar/v3/ANTLRv3.g:167:86: ( ^( 'returns' $rt) )?
+ if ( stream_rt.hasNext()||stream_RET.hasNext() ) {
+ // org/antlr/grammar/v3/ANTLRv3.g:167:86: ^( 'returns' $rt)
+ {
+ CommonTree root_2 = (CommonTree)adaptor.nil();
+ root_2 = (CommonTree)adaptor.becomeRoot(stream_RET.nextNode(), root_2);
+
+ adaptor.addChild(root_2, stream_rt.nextNode());
+
+ adaptor.addChild(root_1, root_2);
+ }
+
+ }
+ stream_rt.reset();
+ stream_RET.reset();
+ // org/antlr/grammar/v3/ANTLRv3.g:168:9: ( throwsSpec )?
+ if ( stream_throwsSpec.hasNext() ) {
+ adaptor.addChild(root_1, stream_throwsSpec.nextTree());
+
+ }
+ stream_throwsSpec.reset();
+ // org/antlr/grammar/v3/ANTLRv3.g:168:21: ( optionsSpec )?
+ if ( stream_optionsSpec.hasNext() ) {
+ adaptor.addChild(root_1, stream_optionsSpec.nextTree());
+
+ }
+ stream_optionsSpec.reset();
+ // org/antlr/grammar/v3/ANTLRv3.g:168:34: ( ruleScopeSpec )?
+ if ( stream_ruleScopeSpec.hasNext() ) {
+ adaptor.addChild(root_1, stream_ruleScopeSpec.nextTree());
+
+ }
+ stream_ruleScopeSpec.reset();
+ // org/antlr/grammar/v3/ANTLRv3.g:168:49: ( ruleAction )*
+ while ( stream_ruleAction.hasNext() ) {
+ adaptor.addChild(root_1, stream_ruleAction.nextTree());
+
+ }
+ stream_ruleAction.reset();
+ adaptor.addChild(root_1, stream_altList.nextTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:170:9: ( exceptionGroup )?
+ if ( stream_exceptionGroup.hasNext() ) {
+ adaptor.addChild(root_1, stream_exceptionGroup.nextTree());
+
+ }
+ stream_exceptionGroup.reset();
+ adaptor.addChild(root_1, (CommonTree)adaptor.create(EOR, "EOR"));
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ rule_stack.pop();
+ }
+ return retval;
+ }
+ // $ANTLR end "rule"
+
+ public static class ruleAction_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "ruleAction"
+ // org/antlr/grammar/v3/ANTLRv3.g:175:1: ruleAction : '@' id ACTION -> ^( '@' id ACTION ) ;
+ public final ANTLRv3Parser.ruleAction_return ruleAction() throws RecognitionException {
+ ANTLRv3Parser.ruleAction_return retval = new ANTLRv3Parser.ruleAction_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token char_literal55=null;
+ Token ACTION57=null;
+ ANTLRv3Parser.id_return id56 = null;
+
+
+ CommonTree char_literal55_tree=null;
+ CommonTree ACTION57_tree=null;
+ RewriteRuleTokenStream stream_AT=new RewriteRuleTokenStream(adaptor,"token AT");
+ RewriteRuleTokenStream stream_ACTION=new RewriteRuleTokenStream(adaptor,"token ACTION");
+ RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:177:2: ( '@' id ACTION -> ^( '@' id ACTION ) )
+ // org/antlr/grammar/v3/ANTLRv3.g:177:4: '@' id ACTION
+ {
+ char_literal55=(Token)match(input,AT,FOLLOW_AT_in_ruleAction1059); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_AT.add(char_literal55);
+
+ pushFollow(FOLLOW_id_in_ruleAction1061);
+ id56=id();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_id.add(id56.getTree());
+ ACTION57=(Token)match(input,ACTION,FOLLOW_ACTION_in_ruleAction1063); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ACTION.add(ACTION57);
+
+
+
+ // AST REWRITE
+ // elements: id, ACTION, AT
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 177:18: -> ^( '@' id ACTION )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:177:21: ^( '@' id ACTION )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_AT.nextNode(), root_1);
+
+ adaptor.addChild(root_1, stream_id.nextTree());
+ adaptor.addChild(root_1, stream_ACTION.nextNode());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "ruleAction"
+
+ public static class throwsSpec_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "throwsSpec"
+ // org/antlr/grammar/v3/ANTLRv3.g:180:1: throwsSpec : 'throws' id ( ',' id )* -> ^( 'throws' ( id )+ ) ;
+ public final ANTLRv3Parser.throwsSpec_return throwsSpec() throws RecognitionException {
+ ANTLRv3Parser.throwsSpec_return retval = new ANTLRv3Parser.throwsSpec_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token string_literal58=null;
+ Token char_literal60=null;
+ ANTLRv3Parser.id_return id59 = null;
+
+ ANTLRv3Parser.id_return id61 = null;
+
+
+ CommonTree string_literal58_tree=null;
+ CommonTree char_literal60_tree=null;
+ RewriteRuleTokenStream stream_79=new RewriteRuleTokenStream(adaptor,"token 79");
+ RewriteRuleTokenStream stream_80=new RewriteRuleTokenStream(adaptor,"token 80");
+ RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:181:2: ( 'throws' id ( ',' id )* -> ^( 'throws' ( id )+ ) )
+ // org/antlr/grammar/v3/ANTLRv3.g:181:4: 'throws' id ( ',' id )*
+ {
+ string_literal58=(Token)match(input,79,FOLLOW_79_in_throwsSpec1084); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_79.add(string_literal58);
+
+ pushFollow(FOLLOW_id_in_throwsSpec1086);
+ id59=id();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_id.add(id59.getTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:181:16: ( ',' id )*
+ loop26:
+ do {
+ int alt26=2;
+ int LA26_0 = input.LA(1);
+
+ if ( (LA26_0==80) ) {
+ alt26=1;
+ }
+
+
+ switch (alt26) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:181:18: ',' id
+ {
+ char_literal60=(Token)match(input,80,FOLLOW_80_in_throwsSpec1090); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_80.add(char_literal60);
+
+ pushFollow(FOLLOW_id_in_throwsSpec1092);
+ id61=id();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_id.add(id61.getTree());
+
+ }
+ break;
+
+ default :
+ break loop26;
+ }
+ } while (true);
+
+
+
+ // AST REWRITE
+ // elements: 79, id
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 181:28: -> ^( 'throws' ( id )+ )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:181:31: ^( 'throws' ( id )+ )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_79.nextNode(), root_1);
+
+ if ( !(stream_id.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_id.hasNext() ) {
+ adaptor.addChild(root_1, stream_id.nextTree());
+
+ }
+ stream_id.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "throwsSpec"
+
+ public static class ruleScopeSpec_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "ruleScopeSpec"
+ // org/antlr/grammar/v3/ANTLRv3.g:184:1: ruleScopeSpec : ( 'scope' ACTION -> ^( 'scope' ACTION ) | 'scope' id ( ',' id )* ';' -> ^( 'scope' ( id )+ ) | 'scope' ACTION 'scope' id ( ',' id )* ';' -> ^( 'scope' ACTION ( id )+ ) );
+ public final ANTLRv3Parser.ruleScopeSpec_return ruleScopeSpec() throws RecognitionException {
+ ANTLRv3Parser.ruleScopeSpec_return retval = new ANTLRv3Parser.ruleScopeSpec_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token string_literal62=null;
+ Token ACTION63=null;
+ Token string_literal64=null;
+ Token char_literal66=null;
+ Token char_literal68=null;
+ Token string_literal69=null;
+ Token ACTION70=null;
+ Token string_literal71=null;
+ Token char_literal73=null;
+ Token char_literal75=null;
+ ANTLRv3Parser.id_return id65 = null;
+
+ ANTLRv3Parser.id_return id67 = null;
+
+ ANTLRv3Parser.id_return id72 = null;
+
+ ANTLRv3Parser.id_return id74 = null;
+
+
+ CommonTree string_literal62_tree=null;
+ CommonTree ACTION63_tree=null;
+ CommonTree string_literal64_tree=null;
+ CommonTree char_literal66_tree=null;
+ CommonTree char_literal68_tree=null;
+ CommonTree string_literal69_tree=null;
+ CommonTree ACTION70_tree=null;
+ CommonTree string_literal71_tree=null;
+ CommonTree char_literal73_tree=null;
+ CommonTree char_literal75_tree=null;
+ RewriteRuleTokenStream stream_SCOPE=new RewriteRuleTokenStream(adaptor,"token SCOPE");
+ RewriteRuleTokenStream stream_80=new RewriteRuleTokenStream(adaptor,"token 80");
+ RewriteRuleTokenStream stream_71=new RewriteRuleTokenStream(adaptor,"token 71");
+ RewriteRuleTokenStream stream_ACTION=new RewriteRuleTokenStream(adaptor,"token ACTION");
+ RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:185:2: ( 'scope' ACTION -> ^( 'scope' ACTION ) | 'scope' id ( ',' id )* ';' -> ^( 'scope' ( id )+ ) | 'scope' ACTION 'scope' id ( ',' id )* ';' -> ^( 'scope' ACTION ( id )+ ) )
+ int alt29=3;
+ int LA29_0 = input.LA(1);
+
+ if ( (LA29_0==SCOPE) ) {
+ int LA29_1 = input.LA(2);
+
+ if ( (LA29_1==ACTION) ) {
+ int LA29_2 = input.LA(3);
+
+ if ( (LA29_2==SCOPE) ) {
+ alt29=3;
+ }
+ else if ( (LA29_2==AT||LA29_2==78) ) {
+ alt29=1;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 29, 2, input);
+
+ throw nvae;
+ }
+ }
+ else if ( (LA29_1==TOKEN_REF||LA29_1==RULE_REF) ) {
+ alt29=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 29, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 29, 0, input);
+
+ throw nvae;
+ }
+ switch (alt29) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:185:4: 'scope' ACTION
+ {
+ string_literal62=(Token)match(input,SCOPE,FOLLOW_SCOPE_in_ruleScopeSpec1115); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_SCOPE.add(string_literal62);
+
+ ACTION63=(Token)match(input,ACTION,FOLLOW_ACTION_in_ruleScopeSpec1117); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ACTION.add(ACTION63);
+
+
+
+ // AST REWRITE
+ // elements: ACTION, SCOPE
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 185:19: -> ^( 'scope' ACTION )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:185:22: ^( 'scope' ACTION )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_SCOPE.nextNode(), root_1);
+
+ adaptor.addChild(root_1, stream_ACTION.nextNode());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:186:4: 'scope' id ( ',' id )* ';'
+ {
+ string_literal64=(Token)match(input,SCOPE,FOLLOW_SCOPE_in_ruleScopeSpec1130); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_SCOPE.add(string_literal64);
+
+ pushFollow(FOLLOW_id_in_ruleScopeSpec1132);
+ id65=id();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_id.add(id65.getTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:186:15: ( ',' id )*
+ loop27:
+ do {
+ int alt27=2;
+ int LA27_0 = input.LA(1);
+
+ if ( (LA27_0==80) ) {
+ alt27=1;
+ }
+
+
+ switch (alt27) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:186:16: ',' id
+ {
+ char_literal66=(Token)match(input,80,FOLLOW_80_in_ruleScopeSpec1135); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_80.add(char_literal66);
+
+ pushFollow(FOLLOW_id_in_ruleScopeSpec1137);
+ id67=id();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_id.add(id67.getTree());
+
+ }
+ break;
+
+ default :
+ break loop27;
+ }
+ } while (true);
+
+ char_literal68=(Token)match(input,71,FOLLOW_71_in_ruleScopeSpec1141); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_71.add(char_literal68);
+
+
+
+ // AST REWRITE
+ // elements: id, SCOPE
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 186:29: -> ^( 'scope' ( id )+ )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:186:32: ^( 'scope' ( id )+ )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_SCOPE.nextNode(), root_1);
+
+ if ( !(stream_id.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_id.hasNext() ) {
+ adaptor.addChild(root_1, stream_id.nextTree());
+
+ }
+ stream_id.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3.g:187:4: 'scope' ACTION 'scope' id ( ',' id )* ';'
+ {
+ string_literal69=(Token)match(input,SCOPE,FOLLOW_SCOPE_in_ruleScopeSpec1155); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_SCOPE.add(string_literal69);
+
+ ACTION70=(Token)match(input,ACTION,FOLLOW_ACTION_in_ruleScopeSpec1157); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ACTION.add(ACTION70);
+
+ string_literal71=(Token)match(input,SCOPE,FOLLOW_SCOPE_in_ruleScopeSpec1161); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_SCOPE.add(string_literal71);
+
+ pushFollow(FOLLOW_id_in_ruleScopeSpec1163);
+ id72=id();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_id.add(id72.getTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:188:14: ( ',' id )*
+ loop28:
+ do {
+ int alt28=2;
+ int LA28_0 = input.LA(1);
+
+ if ( (LA28_0==80) ) {
+ alt28=1;
+ }
+
+
+ switch (alt28) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:188:15: ',' id
+ {
+ char_literal73=(Token)match(input,80,FOLLOW_80_in_ruleScopeSpec1166); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_80.add(char_literal73);
+
+ pushFollow(FOLLOW_id_in_ruleScopeSpec1168);
+ id74=id();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_id.add(id74.getTree());
+
+ }
+ break;
+
+ default :
+ break loop28;
+ }
+ } while (true);
+
+ char_literal75=(Token)match(input,71,FOLLOW_71_in_ruleScopeSpec1172); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_71.add(char_literal75);
+
+
+
+ // AST REWRITE
+ // elements: ACTION, SCOPE, id
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 189:3: -> ^( 'scope' ACTION ( id )+ )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:189:6: ^( 'scope' ACTION ( id )+ )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_SCOPE.nextNode(), root_1);
+
+ adaptor.addChild(root_1, stream_ACTION.nextNode());
+ if ( !(stream_id.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_id.hasNext() ) {
+ adaptor.addChild(root_1, stream_id.nextTree());
+
+ }
+ stream_id.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+
+ }
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "ruleScopeSpec"
+
+ public static class block_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "block"
+ // org/antlr/grammar/v3/ANTLRv3.g:192:1: block : lp= '(' ( (opts= optionsSpec )? ':' )? altpair ( '|' altpair )* rp= ')' -> ^( BLOCK[$lp,\"BLOCK\"] ( optionsSpec )? ( altpair )+ EOB[$rp,\"EOB\"] ) ;
+ public final ANTLRv3Parser.block_return block() throws RecognitionException {
+ ANTLRv3Parser.block_return retval = new ANTLRv3Parser.block_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token lp=null;
+ Token rp=null;
+ Token char_literal76=null;
+ Token char_literal78=null;
+ ANTLRv3Parser.optionsSpec_return opts = null;
+
+ ANTLRv3Parser.altpair_return altpair77 = null;
+
+ ANTLRv3Parser.altpair_return altpair79 = null;
+
+
+ CommonTree lp_tree=null;
+ CommonTree rp_tree=null;
+ CommonTree char_literal76_tree=null;
+ CommonTree char_literal78_tree=null;
+ RewriteRuleTokenStream stream_78=new RewriteRuleTokenStream(adaptor,"token 78");
+ RewriteRuleTokenStream stream_82=new RewriteRuleTokenStream(adaptor,"token 82");
+ RewriteRuleTokenStream stream_83=new RewriteRuleTokenStream(adaptor,"token 83");
+ RewriteRuleTokenStream stream_81=new RewriteRuleTokenStream(adaptor,"token 81");
+ RewriteRuleSubtreeStream stream_altpair=new RewriteRuleSubtreeStream(adaptor,"rule altpair");
+ RewriteRuleSubtreeStream stream_optionsSpec=new RewriteRuleSubtreeStream(adaptor,"rule optionsSpec");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:193:5: (lp= '(' ( (opts= optionsSpec )? ':' )? altpair ( '|' altpair )* rp= ')' -> ^( BLOCK[$lp,\"BLOCK\"] ( optionsSpec )? ( altpair )+ EOB[$rp,\"EOB\"] ) )
+ // org/antlr/grammar/v3/ANTLRv3.g:193:9: lp= '(' ( (opts= optionsSpec )? ':' )? altpair ( '|' altpair )* rp= ')'
+ {
+ lp=(Token)match(input,81,FOLLOW_81_in_block1204); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_81.add(lp);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:194:3: ( (opts= optionsSpec )? ':' )?
+ int alt31=2;
+ int LA31_0 = input.LA(1);
+
+ if ( (LA31_0==OPTIONS||LA31_0==78) ) {
+ alt31=1;
+ }
+ switch (alt31) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:194:5: (opts= optionsSpec )? ':'
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:194:5: (opts= optionsSpec )?
+ int alt30=2;
+ int LA30_0 = input.LA(1);
+
+ if ( (LA30_0==OPTIONS) ) {
+ alt30=1;
+ }
+ switch (alt30) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:194:6: opts= optionsSpec
+ {
+ pushFollow(FOLLOW_optionsSpec_in_block1213);
+ opts=optionsSpec();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_optionsSpec.add(opts.getTree());
+
+ }
+ break;
+
+ }
+
+ char_literal76=(Token)match(input,78,FOLLOW_78_in_block1217); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_78.add(char_literal76);
+
+
+ }
+ break;
+
+ }
+
+ pushFollow(FOLLOW_altpair_in_block1224);
+ altpair77=altpair();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_altpair.add(altpair77.getTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:195:11: ( '|' altpair )*
+ loop32:
+ do {
+ int alt32=2;
+ int LA32_0 = input.LA(1);
+
+ if ( (LA32_0==82) ) {
+ alt32=1;
+ }
+
+
+ switch (alt32) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:195:13: '|' altpair
+ {
+ char_literal78=(Token)match(input,82,FOLLOW_82_in_block1228); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_82.add(char_literal78);
+
+ pushFollow(FOLLOW_altpair_in_block1230);
+ altpair79=altpair();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_altpair.add(altpair79.getTree());
+
+ }
+ break;
+
+ default :
+ break loop32;
+ }
+ } while (true);
+
+ rp=(Token)match(input,83,FOLLOW_83_in_block1245); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_83.add(rp);
+
+
+
+ // AST REWRITE
+ // elements: optionsSpec, altpair
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 197:9: -> ^( BLOCK[$lp,\"BLOCK\"] ( optionsSpec )? ( altpair )+ EOB[$rp,\"EOB\"] )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:197:12: ^( BLOCK[$lp,\"BLOCK\"] ( optionsSpec )? ( altpair )+ EOB[$rp,\"EOB\"] )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(BLOCK, lp, "BLOCK"), root_1);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:197:34: ( optionsSpec )?
+ if ( stream_optionsSpec.hasNext() ) {
+ adaptor.addChild(root_1, stream_optionsSpec.nextTree());
+
+ }
+ stream_optionsSpec.reset();
+ if ( !(stream_altpair.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_altpair.hasNext() ) {
+ adaptor.addChild(root_1, stream_altpair.nextTree());
+
+ }
+ stream_altpair.reset();
+ adaptor.addChild(root_1, (CommonTree)adaptor.create(EOB, rp, "EOB"));
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "block"
+
+ public static class altpair_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "altpair"
+ // org/antlr/grammar/v3/ANTLRv3.g:200:1: altpair : alternative rewrite ;
+ public final ANTLRv3Parser.altpair_return altpair() throws RecognitionException {
+ ANTLRv3Parser.altpair_return retval = new ANTLRv3Parser.altpair_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ ANTLRv3Parser.alternative_return alternative80 = null;
+
+ ANTLRv3Parser.rewrite_return rewrite81 = null;
+
+
+
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:200:9: ( alternative rewrite )
+ // org/antlr/grammar/v3/ANTLRv3.g:200:11: alternative rewrite
+ {
+ root_0 = (CommonTree)adaptor.nil();
+
+ pushFollow(FOLLOW_alternative_in_altpair1284);
+ alternative80=alternative();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) adaptor.addChild(root_0, alternative80.getTree());
+ pushFollow(FOLLOW_rewrite_in_altpair1286);
+ rewrite81=rewrite();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) adaptor.addChild(root_0, rewrite81.getTree());
+
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "altpair"
+
+ public static class altList_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "altList"
+ // org/antlr/grammar/v3/ANTLRv3.g:202:1: altList : altpair ( '|' altpair )* -> ^( ( altpair )+ EOB[\"EOB\"] ) ;
+ public final ANTLRv3Parser.altList_return altList() throws RecognitionException {
+ ANTLRv3Parser.altList_return retval = new ANTLRv3Parser.altList_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token char_literal83=null;
+ ANTLRv3Parser.altpair_return altpair82 = null;
+
+ ANTLRv3Parser.altpair_return altpair84 = null;
+
+
+ CommonTree char_literal83_tree=null;
+ RewriteRuleTokenStream stream_82=new RewriteRuleTokenStream(adaptor,"token 82");
+ RewriteRuleSubtreeStream stream_altpair=new RewriteRuleSubtreeStream(adaptor,"rule altpair");
+
+ // must create root manually as it's used by invoked rules in real antlr tool.
+ // leave here to demonstrate use of {...} in rewrite rule
+ // it's really BLOCK[firstToken,"BLOCK"]; set line/col to previous ( or : token.
+ CommonTree blkRoot = (CommonTree)adaptor.create(BLOCK,input.LT(-1),"BLOCK");
+
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:209:5: ( altpair ( '|' altpair )* -> ^( ( altpair )+ EOB[\"EOB\"] ) )
+ // org/antlr/grammar/v3/ANTLRv3.g:209:9: altpair ( '|' altpair )*
+ {
+ pushFollow(FOLLOW_altpair_in_altList1306);
+ altpair82=altpair();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_altpair.add(altpair82.getTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:209:17: ( '|' altpair )*
+ loop33:
+ do {
+ int alt33=2;
+ int LA33_0 = input.LA(1);
+
+ if ( (LA33_0==82) ) {
+ alt33=1;
+ }
+
+
+ switch (alt33) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:209:19: '|' altpair
+ {
+ char_literal83=(Token)match(input,82,FOLLOW_82_in_altList1310); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_82.add(char_literal83);
+
+ pushFollow(FOLLOW_altpair_in_altList1312);
+ altpair84=altpair();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_altpair.add(altpair84.getTree());
+
+ }
+ break;
+
+ default :
+ break loop33;
+ }
+ } while (true);
+
+
+
+ // AST REWRITE
+ // elements: altpair
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 209:34: -> ^( ( altpair )+ EOB[\"EOB\"] )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:209:37: ^( ( altpair )+ EOB[\"EOB\"] )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(blkRoot, root_1);
+
+ if ( !(stream_altpair.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_altpair.hasNext() ) {
+ adaptor.addChild(root_1, stream_altpair.nextTree());
+
+ }
+ stream_altpair.reset();
+ adaptor.addChild(root_1, (CommonTree)adaptor.create(EOB, "EOB"));
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "altList"
+
+ public static class alternative_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "alternative"
+ // org/antlr/grammar/v3/ANTLRv3.g:212:1: alternative : ( ( element )+ -> ^( ALT[firstToken,\"ALT\"] ( element )+ EOA[\"EOA\"] ) | -> ^( ALT[prevToken,\"ALT\"] EPSILON[prevToken,\"EPSILON\"] EOA[\"EOA\"] ) );
+ public final ANTLRv3Parser.alternative_return alternative() throws RecognitionException {
+ ANTLRv3Parser.alternative_return retval = new ANTLRv3Parser.alternative_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ ANTLRv3Parser.element_return element85 = null;
+
+
+ RewriteRuleSubtreeStream stream_element=new RewriteRuleSubtreeStream(adaptor,"rule element");
+
+ Token firstToken = input.LT(1);
+ Token prevToken = input.LT(-1); // either : or | I think
+
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:217:5: ( ( element )+ -> ^( ALT[firstToken,\"ALT\"] ( element )+ EOA[\"EOA\"] ) | -> ^( ALT[prevToken,\"ALT\"] EPSILON[prevToken,\"EPSILON\"] EOA[\"EOA\"] ) )
+ int alt35=2;
+ int LA35_0 = input.LA(1);
+
+ if ( (LA35_0==SEMPRED||LA35_0==TREE_BEGIN||(LA35_0>=TOKEN_REF && LA35_0<=ACTION)||LA35_0==RULE_REF||LA35_0==81||LA35_0==87||LA35_0==90) ) {
+ alt35=1;
+ }
+ else if ( (LA35_0==REWRITE||LA35_0==71||(LA35_0>=82 && LA35_0<=83)) ) {
+ alt35=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 35, 0, input);
+
+ throw nvae;
+ }
+ switch (alt35) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:217:9: ( element )+
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:217:9: ( element )+
+ int cnt34=0;
+ loop34:
+ do {
+ int alt34=2;
+ int LA34_0 = input.LA(1);
+
+ if ( (LA34_0==SEMPRED||LA34_0==TREE_BEGIN||(LA34_0>=TOKEN_REF && LA34_0<=ACTION)||LA34_0==RULE_REF||LA34_0==81||LA34_0==87||LA34_0==90) ) {
+ alt34=1;
+ }
+
+
+ switch (alt34) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:217:9: element
+ {
+ pushFollow(FOLLOW_element_in_alternative1353);
+ element85=element();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_element.add(element85.getTree());
+
+ }
+ break;
+
+ default :
+ if ( cnt34 >= 1 ) break loop34;
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ EarlyExitException eee =
+ new EarlyExitException(34, input);
+ throw eee;
+ }
+ cnt34++;
+ } while (true);
+
+
+
+ // AST REWRITE
+ // elements: element
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 217:18: -> ^( ALT[firstToken,\"ALT\"] ( element )+ EOA[\"EOA\"] )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:217:21: ^( ALT[firstToken,\"ALT\"] ( element )+ EOA[\"EOA\"] )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ALT, firstToken, "ALT"), root_1);
+
+ if ( !(stream_element.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_element.hasNext() ) {
+ adaptor.addChild(root_1, stream_element.nextTree());
+
+ }
+ stream_element.reset();
+ adaptor.addChild(root_1, (CommonTree)adaptor.create(EOA, "EOA"));
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:218:9:
+ {
+
+ // AST REWRITE
+ // elements:
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 218:9: -> ^( ALT[prevToken,\"ALT\"] EPSILON[prevToken,\"EPSILON\"] EOA[\"EOA\"] )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:218:12: ^( ALT[prevToken,\"ALT\"] EPSILON[prevToken,\"EPSILON\"] EOA[\"EOA\"] )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ALT, prevToken, "ALT"), root_1);
+
+ adaptor.addChild(root_1, (CommonTree)adaptor.create(EPSILON, prevToken, "EPSILON"));
+ adaptor.addChild(root_1, (CommonTree)adaptor.create(EOA, "EOA"));
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+
+ }
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "alternative"
+
+ public static class exceptionGroup_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "exceptionGroup"
+ // org/antlr/grammar/v3/ANTLRv3.g:221:1: exceptionGroup : ( ( exceptionHandler )+ ( finallyClause )? | finallyClause );
+ public final ANTLRv3Parser.exceptionGroup_return exceptionGroup() throws RecognitionException {
+ ANTLRv3Parser.exceptionGroup_return retval = new ANTLRv3Parser.exceptionGroup_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ ANTLRv3Parser.exceptionHandler_return exceptionHandler86 = null;
+
+ ANTLRv3Parser.finallyClause_return finallyClause87 = null;
+
+ ANTLRv3Parser.finallyClause_return finallyClause88 = null;
+
+
+
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:222:2: ( ( exceptionHandler )+ ( finallyClause )? | finallyClause )
+ int alt38=2;
+ int LA38_0 = input.LA(1);
+
+ if ( (LA38_0==84) ) {
+ alt38=1;
+ }
+ else if ( (LA38_0==85) ) {
+ alt38=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 38, 0, input);
+
+ throw nvae;
+ }
+ switch (alt38) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:222:4: ( exceptionHandler )+ ( finallyClause )?
+ {
+ root_0 = (CommonTree)adaptor.nil();
+
+ // org/antlr/grammar/v3/ANTLRv3.g:222:4: ( exceptionHandler )+
+ int cnt36=0;
+ loop36:
+ do {
+ int alt36=2;
+ int LA36_0 = input.LA(1);
+
+ if ( (LA36_0==84) ) {
+ alt36=1;
+ }
+
+
+ switch (alt36) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:222:6: exceptionHandler
+ {
+ pushFollow(FOLLOW_exceptionHandler_in_exceptionGroup1404);
+ exceptionHandler86=exceptionHandler();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) adaptor.addChild(root_0, exceptionHandler86.getTree());
+
+ }
+ break;
+
+ default :
+ if ( cnt36 >= 1 ) break loop36;
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ EarlyExitException eee =
+ new EarlyExitException(36, input);
+ throw eee;
+ }
+ cnt36++;
+ } while (true);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:222:26: ( finallyClause )?
+ int alt37=2;
+ int LA37_0 = input.LA(1);
+
+ if ( (LA37_0==85) ) {
+ alt37=1;
+ }
+ switch (alt37) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:222:28: finallyClause
+ {
+ pushFollow(FOLLOW_finallyClause_in_exceptionGroup1411);
+ finallyClause87=finallyClause();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) adaptor.addChild(root_0, finallyClause87.getTree());
+
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:223:4: finallyClause
+ {
+ root_0 = (CommonTree)adaptor.nil();
+
+ pushFollow(FOLLOW_finallyClause_in_exceptionGroup1419);
+ finallyClause88=finallyClause();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) adaptor.addChild(root_0, finallyClause88.getTree());
+
+ }
+ break;
+
+ }
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "exceptionGroup"
+
+ public static class exceptionHandler_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "exceptionHandler"
+ // org/antlr/grammar/v3/ANTLRv3.g:226:1: exceptionHandler : 'catch' ARG_ACTION ACTION -> ^( 'catch' ARG_ACTION ACTION ) ;
+ public final ANTLRv3Parser.exceptionHandler_return exceptionHandler() throws RecognitionException {
+ ANTLRv3Parser.exceptionHandler_return retval = new ANTLRv3Parser.exceptionHandler_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token string_literal89=null;
+ Token ARG_ACTION90=null;
+ Token ACTION91=null;
+
+ CommonTree string_literal89_tree=null;
+ CommonTree ARG_ACTION90_tree=null;
+ CommonTree ACTION91_tree=null;
+ RewriteRuleTokenStream stream_ACTION=new RewriteRuleTokenStream(adaptor,"token ACTION");
+ RewriteRuleTokenStream stream_84=new RewriteRuleTokenStream(adaptor,"token 84");
+ RewriteRuleTokenStream stream_ARG_ACTION=new RewriteRuleTokenStream(adaptor,"token ARG_ACTION");
+
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:227:5: ( 'catch' ARG_ACTION ACTION -> ^( 'catch' ARG_ACTION ACTION ) )
+ // org/antlr/grammar/v3/ANTLRv3.g:227:10: 'catch' ARG_ACTION ACTION
+ {
+ string_literal89=(Token)match(input,84,FOLLOW_84_in_exceptionHandler1439); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_84.add(string_literal89);
+
+ ARG_ACTION90=(Token)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_exceptionHandler1441); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ARG_ACTION.add(ARG_ACTION90);
+
+ ACTION91=(Token)match(input,ACTION,FOLLOW_ACTION_in_exceptionHandler1443); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ACTION.add(ACTION91);
+
+
+
+ // AST REWRITE
+ // elements: 84, ARG_ACTION, ACTION
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 227:36: -> ^( 'catch' ARG_ACTION ACTION )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:227:39: ^( 'catch' ARG_ACTION ACTION )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_84.nextNode(), root_1);
+
+ adaptor.addChild(root_1, stream_ARG_ACTION.nextNode());
+ adaptor.addChild(root_1, stream_ACTION.nextNode());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "exceptionHandler"
+
+ public static class finallyClause_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "finallyClause"
+ // org/antlr/grammar/v3/ANTLRv3.g:230:1: finallyClause : 'finally' ACTION -> ^( 'finally' ACTION ) ;
+ public final ANTLRv3Parser.finallyClause_return finallyClause() throws RecognitionException {
+ ANTLRv3Parser.finallyClause_return retval = new ANTLRv3Parser.finallyClause_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token string_literal92=null;
+ Token ACTION93=null;
+
+ CommonTree string_literal92_tree=null;
+ CommonTree ACTION93_tree=null;
+ RewriteRuleTokenStream stream_ACTION=new RewriteRuleTokenStream(adaptor,"token ACTION");
+ RewriteRuleTokenStream stream_85=new RewriteRuleTokenStream(adaptor,"token 85");
+
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:231:5: ( 'finally' ACTION -> ^( 'finally' ACTION ) )
+ // org/antlr/grammar/v3/ANTLRv3.g:231:10: 'finally' ACTION
+ {
+ string_literal92=(Token)match(input,85,FOLLOW_85_in_finallyClause1473); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_85.add(string_literal92);
+
+ ACTION93=(Token)match(input,ACTION,FOLLOW_ACTION_in_finallyClause1475); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ACTION.add(ACTION93);
+
+
+
+ // AST REWRITE
+ // elements: ACTION, 85
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 231:27: -> ^( 'finally' ACTION )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:231:30: ^( 'finally' ACTION )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_85.nextNode(), root_1);
+
+ adaptor.addChild(root_1, stream_ACTION.nextNode());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "finallyClause"
+
+ public static class element_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "element"
+ // org/antlr/grammar/v3/ANTLRv3.g:234:1: element : ( id (labelOp= '=' | labelOp= '+=' ) atom ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] ^( $labelOp id atom ) EOA[\"EOA\"] ) EOB[\"EOB\"] ) ) | -> ^( $labelOp id atom ) ) | id (labelOp= '=' | labelOp= '+=' ) block ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] ^( $labelOp id block ) EOA[\"EOA\"] ) EOB[\"EOB\"] ) ) | -> ^( $labelOp id block ) ) | atom ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[\"BLOC [...]
+ public final ANTLRv3Parser.element_return element() throws RecognitionException {
+ ANTLRv3Parser.element_return retval = new ANTLRv3Parser.element_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token labelOp=null;
+ Token g=null;
+ Token ACTION103=null;
+ Token SEMPRED104=null;
+ ANTLRv3Parser.id_return id94 = null;
+
+ ANTLRv3Parser.atom_return atom95 = null;
+
+ ANTLRv3Parser.ebnfSuffix_return ebnfSuffix96 = null;
+
+ ANTLRv3Parser.id_return id97 = null;
+
+ ANTLRv3Parser.block_return block98 = null;
+
+ ANTLRv3Parser.ebnfSuffix_return ebnfSuffix99 = null;
+
+ ANTLRv3Parser.atom_return atom100 = null;
+
+ ANTLRv3Parser.ebnfSuffix_return ebnfSuffix101 = null;
+
+ ANTLRv3Parser.ebnf_return ebnf102 = null;
+
+ ANTLRv3Parser.treeSpec_return treeSpec105 = null;
+
+ ANTLRv3Parser.ebnfSuffix_return ebnfSuffix106 = null;
+
+
+ CommonTree labelOp_tree=null;
+ CommonTree g_tree=null;
+ CommonTree ACTION103_tree=null;
+ CommonTree SEMPRED104_tree=null;
+ RewriteRuleTokenStream stream_LIST_LABEL_ASSIGN=new RewriteRuleTokenStream(adaptor,"token LIST_LABEL_ASSIGN");
+ RewriteRuleTokenStream stream_LABEL_ASSIGN=new RewriteRuleTokenStream(adaptor,"token LABEL_ASSIGN");
+ RewriteRuleTokenStream stream_SEMPRED=new RewriteRuleTokenStream(adaptor,"token SEMPRED");
+ RewriteRuleTokenStream stream_86=new RewriteRuleTokenStream(adaptor,"token 86");
+ RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
+ RewriteRuleSubtreeStream stream_atom=new RewriteRuleSubtreeStream(adaptor,"rule atom");
+ RewriteRuleSubtreeStream stream_ebnfSuffix=new RewriteRuleSubtreeStream(adaptor,"rule ebnfSuffix");
+ RewriteRuleSubtreeStream stream_block=new RewriteRuleSubtreeStream(adaptor,"rule block");
+ RewriteRuleSubtreeStream stream_treeSpec=new RewriteRuleSubtreeStream(adaptor,"rule treeSpec");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:235:2: ( id (labelOp= '=' | labelOp= '+=' ) atom ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] ^( $labelOp id atom ) EOA[\"EOA\"] ) EOB[\"EOB\"] ) ) | -> ^( $labelOp id atom ) ) | id (labelOp= '=' | labelOp= '+=' ) block ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] ^( $labelOp id block ) EOA[\"EOA\"] ) EOB[\"EOB\"] ) ) | -> ^( $labelOp id block ) ) | atom ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\ [...]
+ int alt46=7;
+ alt46 = dfa46.predict(input);
+ switch (alt46) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:235:4: id (labelOp= '=' | labelOp= '+=' ) atom ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] ^( $labelOp id atom ) EOA[\"EOA\"] ) EOB[\"EOB\"] ) ) | -> ^( $labelOp id atom ) )
+ {
+ pushFollow(FOLLOW_id_in_element1497);
+ id94=id();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_id.add(id94.getTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:235:7: (labelOp= '=' | labelOp= '+=' )
+ int alt39=2;
+ int LA39_0 = input.LA(1);
+
+ if ( (LA39_0==LABEL_ASSIGN) ) {
+ alt39=1;
+ }
+ else if ( (LA39_0==LIST_LABEL_ASSIGN) ) {
+ alt39=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 39, 0, input);
+
+ throw nvae;
+ }
+ switch (alt39) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:235:8: labelOp= '='
+ {
+ labelOp=(Token)match(input,LABEL_ASSIGN,FOLLOW_LABEL_ASSIGN_in_element1502); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_LABEL_ASSIGN.add(labelOp);
+
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:235:20: labelOp= '+='
+ {
+ labelOp=(Token)match(input,LIST_LABEL_ASSIGN,FOLLOW_LIST_LABEL_ASSIGN_in_element1506); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_LIST_LABEL_ASSIGN.add(labelOp);
+
+
+ }
+ break;
+
+ }
+
+ pushFollow(FOLLOW_atom_in_element1509);
+ atom95=atom();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_atom.add(atom95.getTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:236:3: ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] ^( $labelOp id atom ) EOA[\"EOA\"] ) EOB[\"EOB\"] ) ) | -> ^( $labelOp id atom ) )
+ int alt40=2;
+ int LA40_0 = input.LA(1);
+
+ if ( (LA40_0==74||(LA40_0>=91 && LA40_0<=92)) ) {
+ alt40=1;
+ }
+ else if ( (LA40_0==SEMPRED||LA40_0==TREE_BEGIN||LA40_0==REWRITE||(LA40_0>=TOKEN_REF && LA40_0<=ACTION)||LA40_0==RULE_REF||LA40_0==71||(LA40_0>=81 && LA40_0<=83)||LA40_0==87||LA40_0==90) ) {
+ alt40=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 40, 0, input);
+
+ throw nvae;
+ }
+ switch (alt40) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:236:5: ebnfSuffix
+ {
+ pushFollow(FOLLOW_ebnfSuffix_in_element1515);
+ ebnfSuffix96=ebnfSuffix();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ebnfSuffix.add(ebnfSuffix96.getTree());
+
+
+ // AST REWRITE
+ // elements: id, labelOp, ebnfSuffix, atom
+ // token labels: labelOp
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleTokenStream stream_labelOp=new RewriteRuleTokenStream(adaptor,"token labelOp",labelOp);
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 236:16: -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] ^( $labelOp id atom ) EOA[\"EOA\"] ) EOB[\"EOB\"] ) )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:236:19: ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] ^( $labelOp id atom ) EOA[\"EOA\"] ) EOB[\"EOB\"] ) )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_ebnfSuffix.nextNode(), root_1);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:236:33: ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] ^( $labelOp id atom ) EOA[\"EOA\"] ) EOB[\"EOB\"] )
+ {
+ CommonTree root_2 = (CommonTree)adaptor.nil();
+ root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(BLOCK, "BLOCK"), root_2);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:236:50: ^( ALT[\"ALT\"] ^( $labelOp id atom ) EOA[\"EOA\"] )
+ {
+ CommonTree root_3 = (CommonTree)adaptor.nil();
+ root_3 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ALT, "ALT"), root_3);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:236:63: ^( $labelOp id atom )
+ {
+ CommonTree root_4 = (CommonTree)adaptor.nil();
+ root_4 = (CommonTree)adaptor.becomeRoot(stream_labelOp.nextNode(), root_4);
+
+ adaptor.addChild(root_4, stream_id.nextTree());
+ adaptor.addChild(root_4, stream_atom.nextTree());
+
+ adaptor.addChild(root_3, root_4);
+ }
+ adaptor.addChild(root_3, (CommonTree)adaptor.create(EOA, "EOA"));
+
+ adaptor.addChild(root_2, root_3);
+ }
+ adaptor.addChild(root_2, (CommonTree)adaptor.create(EOB, "EOB"));
+
+ adaptor.addChild(root_1, root_2);
+ }
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:237:8:
+ {
+
+ // AST REWRITE
+ // elements: labelOp, id, atom
+ // token labels: labelOp
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleTokenStream stream_labelOp=new RewriteRuleTokenStream(adaptor,"token labelOp",labelOp);
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 237:8: -> ^( $labelOp id atom )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:237:11: ^( $labelOp id atom )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_labelOp.nextNode(), root_1);
+
+ adaptor.addChild(root_1, stream_id.nextTree());
+ adaptor.addChild(root_1, stream_atom.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:239:4: id (labelOp= '=' | labelOp= '+=' ) block ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] ^( $labelOp id block ) EOA[\"EOA\"] ) EOB[\"EOB\"] ) ) | -> ^( $labelOp id block ) )
+ {
+ pushFollow(FOLLOW_id_in_element1574);
+ id97=id();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_id.add(id97.getTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:239:7: (labelOp= '=' | labelOp= '+=' )
+ int alt41=2;
+ int LA41_0 = input.LA(1);
+
+ if ( (LA41_0==LABEL_ASSIGN) ) {
+ alt41=1;
+ }
+ else if ( (LA41_0==LIST_LABEL_ASSIGN) ) {
+ alt41=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 41, 0, input);
+
+ throw nvae;
+ }
+ switch (alt41) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:239:8: labelOp= '='
+ {
+ labelOp=(Token)match(input,LABEL_ASSIGN,FOLLOW_LABEL_ASSIGN_in_element1579); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_LABEL_ASSIGN.add(labelOp);
+
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:239:20: labelOp= '+='
+ {
+ labelOp=(Token)match(input,LIST_LABEL_ASSIGN,FOLLOW_LIST_LABEL_ASSIGN_in_element1583); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_LIST_LABEL_ASSIGN.add(labelOp);
+
+
+ }
+ break;
+
+ }
+
+ pushFollow(FOLLOW_block_in_element1586);
+ block98=block();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_block.add(block98.getTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:240:3: ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] ^( $labelOp id block ) EOA[\"EOA\"] ) EOB[\"EOB\"] ) ) | -> ^( $labelOp id block ) )
+ int alt42=2;
+ int LA42_0 = input.LA(1);
+
+ if ( (LA42_0==74||(LA42_0>=91 && LA42_0<=92)) ) {
+ alt42=1;
+ }
+ else if ( (LA42_0==SEMPRED||LA42_0==TREE_BEGIN||LA42_0==REWRITE||(LA42_0>=TOKEN_REF && LA42_0<=ACTION)||LA42_0==RULE_REF||LA42_0==71||(LA42_0>=81 && LA42_0<=83)||LA42_0==87||LA42_0==90) ) {
+ alt42=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 42, 0, input);
+
+ throw nvae;
+ }
+ switch (alt42) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:240:5: ebnfSuffix
+ {
+ pushFollow(FOLLOW_ebnfSuffix_in_element1592);
+ ebnfSuffix99=ebnfSuffix();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ebnfSuffix.add(ebnfSuffix99.getTree());
+
+
+ // AST REWRITE
+ // elements: block, id, ebnfSuffix, labelOp
+ // token labels: labelOp
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleTokenStream stream_labelOp=new RewriteRuleTokenStream(adaptor,"token labelOp",labelOp);
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 240:16: -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] ^( $labelOp id block ) EOA[\"EOA\"] ) EOB[\"EOB\"] ) )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:240:19: ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] ^( $labelOp id block ) EOA[\"EOA\"] ) EOB[\"EOB\"] ) )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_ebnfSuffix.nextNode(), root_1);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:240:33: ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] ^( $labelOp id block ) EOA[\"EOA\"] ) EOB[\"EOB\"] )
+ {
+ CommonTree root_2 = (CommonTree)adaptor.nil();
+ root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(BLOCK, "BLOCK"), root_2);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:240:50: ^( ALT[\"ALT\"] ^( $labelOp id block ) EOA[\"EOA\"] )
+ {
+ CommonTree root_3 = (CommonTree)adaptor.nil();
+ root_3 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ALT, "ALT"), root_3);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:240:63: ^( $labelOp id block )
+ {
+ CommonTree root_4 = (CommonTree)adaptor.nil();
+ root_4 = (CommonTree)adaptor.becomeRoot(stream_labelOp.nextNode(), root_4);
+
+ adaptor.addChild(root_4, stream_id.nextTree());
+ adaptor.addChild(root_4, stream_block.nextTree());
+
+ adaptor.addChild(root_3, root_4);
+ }
+ adaptor.addChild(root_3, (CommonTree)adaptor.create(EOA, "EOA"));
+
+ adaptor.addChild(root_2, root_3);
+ }
+ adaptor.addChild(root_2, (CommonTree)adaptor.create(EOB, "EOB"));
+
+ adaptor.addChild(root_1, root_2);
+ }
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:241:8:
+ {
+
+ // AST REWRITE
+ // elements: id, labelOp, block
+ // token labels: labelOp
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleTokenStream stream_labelOp=new RewriteRuleTokenStream(adaptor,"token labelOp",labelOp);
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 241:8: -> ^( $labelOp id block )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:241:11: ^( $labelOp id block )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_labelOp.nextNode(), root_1);
+
+ adaptor.addChild(root_1, stream_id.nextTree());
+ adaptor.addChild(root_1, stream_block.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3.g:243:4: atom ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] atom EOA[\"EOA\"] ) EOB[\"EOB\"] ) ) | -> atom )
+ {
+ pushFollow(FOLLOW_atom_in_element1651);
+ atom100=atom();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_atom.add(atom100.getTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:244:3: ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] atom EOA[\"EOA\"] ) EOB[\"EOB\"] ) ) | -> atom )
+ int alt43=2;
+ int LA43_0 = input.LA(1);
+
+ if ( (LA43_0==74||(LA43_0>=91 && LA43_0<=92)) ) {
+ alt43=1;
+ }
+ else if ( (LA43_0==SEMPRED||LA43_0==TREE_BEGIN||LA43_0==REWRITE||(LA43_0>=TOKEN_REF && LA43_0<=ACTION)||LA43_0==RULE_REF||LA43_0==71||(LA43_0>=81 && LA43_0<=83)||LA43_0==87||LA43_0==90) ) {
+ alt43=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 43, 0, input);
+
+ throw nvae;
+ }
+ switch (alt43) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:244:5: ebnfSuffix
+ {
+ pushFollow(FOLLOW_ebnfSuffix_in_element1657);
+ ebnfSuffix101=ebnfSuffix();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ebnfSuffix.add(ebnfSuffix101.getTree());
+
+
+ // AST REWRITE
+ // elements: atom, ebnfSuffix
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 244:16: -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] atom EOA[\"EOA\"] ) EOB[\"EOB\"] ) )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:244:19: ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] atom EOA[\"EOA\"] ) EOB[\"EOB\"] ) )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_ebnfSuffix.nextNode(), root_1);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:244:33: ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] atom EOA[\"EOA\"] ) EOB[\"EOB\"] )
+ {
+ CommonTree root_2 = (CommonTree)adaptor.nil();
+ root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(BLOCK, "BLOCK"), root_2);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:244:50: ^( ALT[\"ALT\"] atom EOA[\"EOA\"] )
+ {
+ CommonTree root_3 = (CommonTree)adaptor.nil();
+ root_3 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ALT, "ALT"), root_3);
+
+ adaptor.addChild(root_3, stream_atom.nextTree());
+ adaptor.addChild(root_3, (CommonTree)adaptor.create(EOA, "EOA"));
+
+ adaptor.addChild(root_2, root_3);
+ }
+ adaptor.addChild(root_2, (CommonTree)adaptor.create(EOB, "EOB"));
+
+ adaptor.addChild(root_1, root_2);
+ }
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:245:8:
+ {
+
+ // AST REWRITE
+ // elements: atom
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 245:8: -> atom
+ {
+ adaptor.addChild(root_0, stream_atom.nextTree());
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+ case 4 :
+ // org/antlr/grammar/v3/ANTLRv3.g:247:4: ebnf
+ {
+ root_0 = (CommonTree)adaptor.nil();
+
+ pushFollow(FOLLOW_ebnf_in_element1703);
+ ebnf102=ebnf();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) adaptor.addChild(root_0, ebnf102.getTree());
+
+ }
+ break;
+ case 5 :
+ // org/antlr/grammar/v3/ANTLRv3.g:248:6: ACTION
+ {
+ root_0 = (CommonTree)adaptor.nil();
+
+ ACTION103=(Token)match(input,ACTION,FOLLOW_ACTION_in_element1710); if (state.failed) return retval;
+ if ( state.backtracking==0 ) {
+ ACTION103_tree = (CommonTree)adaptor.create(ACTION103);
+ adaptor.addChild(root_0, ACTION103_tree);
+ }
+
+ }
+ break;
+ case 6 :
+ // org/antlr/grammar/v3/ANTLRv3.g:249:6: SEMPRED (g= '=>' -> GATED_SEMPRED[$g] | -> SEMPRED )
+ {
+ SEMPRED104=(Token)match(input,SEMPRED,FOLLOW_SEMPRED_in_element1717); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_SEMPRED.add(SEMPRED104);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:249:14: (g= '=>' -> GATED_SEMPRED[$g] | -> SEMPRED )
+ int alt44=2;
+ int LA44_0 = input.LA(1);
+
+ if ( (LA44_0==86) ) {
+ alt44=1;
+ }
+ else if ( (LA44_0==SEMPRED||LA44_0==TREE_BEGIN||LA44_0==REWRITE||(LA44_0>=TOKEN_REF && LA44_0<=ACTION)||LA44_0==RULE_REF||LA44_0==71||(LA44_0>=81 && LA44_0<=83)||LA44_0==87||LA44_0==90) ) {
+ alt44=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 44, 0, input);
+
+ throw nvae;
+ }
+ switch (alt44) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:249:16: g= '=>'
+ {
+ g=(Token)match(input,86,FOLLOW_86_in_element1723); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_86.add(g);
+
+
+
+ // AST REWRITE
+ // elements:
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 249:23: -> GATED_SEMPRED[$g]
+ {
+ adaptor.addChild(root_0, (CommonTree)adaptor.create(GATED_SEMPRED, g));
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:249:46:
+ {
+
+ // AST REWRITE
+ // elements: SEMPRED
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 249:46: -> SEMPRED
+ {
+ adaptor.addChild(root_0, stream_SEMPRED.nextNode());
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+ case 7 :
+ // org/antlr/grammar/v3/ANTLRv3.g:250:6: treeSpec ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] treeSpec EOA[\"EOA\"] ) EOB[\"EOB\"] ) ) | -> treeSpec )
+ {
+ pushFollow(FOLLOW_treeSpec_in_element1743);
+ treeSpec105=treeSpec();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_treeSpec.add(treeSpec105.getTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:251:3: ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] treeSpec EOA[\"EOA\"] ) EOB[\"EOB\"] ) ) | -> treeSpec )
+ int alt45=2;
+ int LA45_0 = input.LA(1);
+
+ if ( (LA45_0==74||(LA45_0>=91 && LA45_0<=92)) ) {
+ alt45=1;
+ }
+ else if ( (LA45_0==SEMPRED||LA45_0==TREE_BEGIN||LA45_0==REWRITE||(LA45_0>=TOKEN_REF && LA45_0<=ACTION)||LA45_0==RULE_REF||LA45_0==71||(LA45_0>=81 && LA45_0<=83)||LA45_0==87||LA45_0==90) ) {
+ alt45=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 45, 0, input);
+
+ throw nvae;
+ }
+ switch (alt45) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:251:5: ebnfSuffix
+ {
+ pushFollow(FOLLOW_ebnfSuffix_in_element1749);
+ ebnfSuffix106=ebnfSuffix();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ebnfSuffix.add(ebnfSuffix106.getTree());
+
+
+ // AST REWRITE
+ // elements: treeSpec, ebnfSuffix
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 251:16: -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] treeSpec EOA[\"EOA\"] ) EOB[\"EOB\"] ) )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:251:19: ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] treeSpec EOA[\"EOA\"] ) EOB[\"EOB\"] ) )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_ebnfSuffix.nextNode(), root_1);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:251:33: ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] treeSpec EOA[\"EOA\"] ) EOB[\"EOB\"] )
+ {
+ CommonTree root_2 = (CommonTree)adaptor.nil();
+ root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(BLOCK, "BLOCK"), root_2);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:251:50: ^( ALT[\"ALT\"] treeSpec EOA[\"EOA\"] )
+ {
+ CommonTree root_3 = (CommonTree)adaptor.nil();
+ root_3 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ALT, "ALT"), root_3);
+
+ adaptor.addChild(root_3, stream_treeSpec.nextTree());
+ adaptor.addChild(root_3, (CommonTree)adaptor.create(EOA, "EOA"));
+
+ adaptor.addChild(root_2, root_3);
+ }
+ adaptor.addChild(root_2, (CommonTree)adaptor.create(EOB, "EOB"));
+
+ adaptor.addChild(root_1, root_2);
+ }
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:252:8:
+ {
+
+ // AST REWRITE
+ // elements: treeSpec
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 252:8: -> treeSpec
+ {
+ adaptor.addChild(root_0, stream_treeSpec.nextTree());
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+
+ }
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "element"
+
+ public static class atom_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "atom"
+ // org/antlr/grammar/v3/ANTLRv3.g:256:1: atom : ( terminal | range ( (op= '^' | op= '!' ) -> ^( $op range ) | -> range ) | notSet ( (op= '^' | op= '!' ) -> ^( $op notSet ) | -> notSet ) | RULE_REF ( ARG_ACTION )? ( (op= '^' | op= '!' ) -> ^( $op RULE_REF ( ARG_ACTION )? ) | -> ^( RULE_REF ( ARG_ACTION )? ) ) );
+ public final ANTLRv3Parser.atom_return atom() throws RecognitionException {
+ ANTLRv3Parser.atom_return retval = new ANTLRv3Parser.atom_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token op=null;
+ Token RULE_REF110=null;
+ Token ARG_ACTION111=null;
+ ANTLRv3Parser.terminal_return terminal107 = null;
+
+ ANTLRv3Parser.range_return range108 = null;
+
+ ANTLRv3Parser.notSet_return notSet109 = null;
+
+
+ CommonTree op_tree=null;
+ CommonTree RULE_REF110_tree=null;
+ CommonTree ARG_ACTION111_tree=null;
+ RewriteRuleTokenStream stream_BANG=new RewriteRuleTokenStream(adaptor,"token BANG");
+ RewriteRuleTokenStream stream_ROOT=new RewriteRuleTokenStream(adaptor,"token ROOT");
+ RewriteRuleTokenStream stream_RULE_REF=new RewriteRuleTokenStream(adaptor,"token RULE_REF");
+ RewriteRuleTokenStream stream_ARG_ACTION=new RewriteRuleTokenStream(adaptor,"token ARG_ACTION");
+ RewriteRuleSubtreeStream stream_range=new RewriteRuleSubtreeStream(adaptor,"rule range");
+ RewriteRuleSubtreeStream stream_notSet=new RewriteRuleSubtreeStream(adaptor,"rule notSet");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:256:5: ( terminal | range ( (op= '^' | op= '!' ) -> ^( $op range ) | -> range ) | notSet ( (op= '^' | op= '!' ) -> ^( $op notSet ) | -> notSet ) | RULE_REF ( ARG_ACTION )? ( (op= '^' | op= '!' ) -> ^( $op RULE_REF ( ARG_ACTION )? ) | -> ^( RULE_REF ( ARG_ACTION )? ) ) )
+ int alt54=4;
+ switch ( input.LA(1) ) {
+ case CHAR_LITERAL:
+ {
+ int LA54_1 = input.LA(2);
+
+ if ( (LA54_1==RANGE) ) {
+ alt54=2;
+ }
+ else if ( (LA54_1==SEMPRED||(LA54_1>=TREE_BEGIN && LA54_1<=REWRITE)||(LA54_1>=TOKEN_REF && LA54_1<=ACTION)||LA54_1==RULE_REF||LA54_1==71||LA54_1==74||(LA54_1>=81 && LA54_1<=83)||(LA54_1>=87 && LA54_1<=88)||(LA54_1>=90 && LA54_1<=92)) ) {
+ alt54=1;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 54, 1, input);
+
+ throw nvae;
+ }
+ }
+ break;
+ case TOKEN_REF:
+ case STRING_LITERAL:
+ case 90:
+ {
+ alt54=1;
+ }
+ break;
+ case 87:
+ {
+ alt54=3;
+ }
+ break;
+ case RULE_REF:
+ {
+ alt54=4;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 54, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt54) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:256:9: terminal
+ {
+ root_0 = (CommonTree)adaptor.nil();
+
+ pushFollow(FOLLOW_terminal_in_atom1801);
+ terminal107=terminal();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) adaptor.addChild(root_0, terminal107.getTree());
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:257:4: range ( (op= '^' | op= '!' ) -> ^( $op range ) | -> range )
+ {
+ pushFollow(FOLLOW_range_in_atom1806);
+ range108=range();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_range.add(range108.getTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:258:3: ( (op= '^' | op= '!' ) -> ^( $op range ) | -> range )
+ int alt48=2;
+ int LA48_0 = input.LA(1);
+
+ if ( ((LA48_0>=ROOT && LA48_0<=BANG)) ) {
+ alt48=1;
+ }
+ else if ( (LA48_0==SEMPRED||LA48_0==TREE_BEGIN||LA48_0==REWRITE||(LA48_0>=TOKEN_REF && LA48_0<=ACTION)||LA48_0==RULE_REF||LA48_0==71||LA48_0==74||(LA48_0>=81 && LA48_0<=83)||LA48_0==87||(LA48_0>=90 && LA48_0<=92)) ) {
+ alt48=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 48, 0, input);
+
+ throw nvae;
+ }
+ switch (alt48) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:258:5: (op= '^' | op= '!' )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:258:5: (op= '^' | op= '!' )
+ int alt47=2;
+ int LA47_0 = input.LA(1);
+
+ if ( (LA47_0==ROOT) ) {
+ alt47=1;
+ }
+ else if ( (LA47_0==BANG) ) {
+ alt47=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 47, 0, input);
+
+ throw nvae;
+ }
+ switch (alt47) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:258:6: op= '^'
+ {
+ op=(Token)match(input,ROOT,FOLLOW_ROOT_in_atom1816); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ROOT.add(op);
+
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:258:13: op= '!'
+ {
+ op=(Token)match(input,BANG,FOLLOW_BANG_in_atom1820); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_BANG.add(op);
+
+
+ }
+ break;
+
+ }
+
+
+
+ // AST REWRITE
+ // elements: op, range
+ // token labels: op
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleTokenStream stream_op=new RewriteRuleTokenStream(adaptor,"token op",op);
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 258:21: -> ^( $op range )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:258:24: ^( $op range )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_op.nextNode(), root_1);
+
+ adaptor.addChild(root_1, stream_range.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:259:9:
+ {
+
+ // AST REWRITE
+ // elements: range
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 259:9: -> range
+ {
+ adaptor.addChild(root_0, stream_range.nextTree());
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3.g:261:7: notSet ( (op= '^' | op= '!' ) -> ^( $op notSet ) | -> notSet )
+ {
+ pushFollow(FOLLOW_notSet_in_atom1854);
+ notSet109=notSet();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_notSet.add(notSet109.getTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:262:3: ( (op= '^' | op= '!' ) -> ^( $op notSet ) | -> notSet )
+ int alt50=2;
+ int LA50_0 = input.LA(1);
+
+ if ( ((LA50_0>=ROOT && LA50_0<=BANG)) ) {
+ alt50=1;
+ }
+ else if ( (LA50_0==SEMPRED||LA50_0==TREE_BEGIN||LA50_0==REWRITE||(LA50_0>=TOKEN_REF && LA50_0<=ACTION)||LA50_0==RULE_REF||LA50_0==71||LA50_0==74||(LA50_0>=81 && LA50_0<=83)||LA50_0==87||(LA50_0>=90 && LA50_0<=92)) ) {
+ alt50=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 50, 0, input);
+
+ throw nvae;
+ }
+ switch (alt50) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:262:5: (op= '^' | op= '!' )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:262:5: (op= '^' | op= '!' )
+ int alt49=2;
+ int LA49_0 = input.LA(1);
+
+ if ( (LA49_0==ROOT) ) {
+ alt49=1;
+ }
+ else if ( (LA49_0==BANG) ) {
+ alt49=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 49, 0, input);
+
+ throw nvae;
+ }
+ switch (alt49) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:262:6: op= '^'
+ {
+ op=(Token)match(input,ROOT,FOLLOW_ROOT_in_atom1863); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ROOT.add(op);
+
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:262:13: op= '!'
+ {
+ op=(Token)match(input,BANG,FOLLOW_BANG_in_atom1867); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_BANG.add(op);
+
+
+ }
+ break;
+
+ }
+
+
+
+ // AST REWRITE
+ // elements: op, notSet
+ // token labels: op
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleTokenStream stream_op=new RewriteRuleTokenStream(adaptor,"token op",op);
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 262:21: -> ^( $op notSet )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:262:24: ^( $op notSet )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_op.nextNode(), root_1);
+
+ adaptor.addChild(root_1, stream_notSet.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:263:9:
+ {
+
+ // AST REWRITE
+ // elements: notSet
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 263:9: -> notSet
+ {
+ adaptor.addChild(root_0, stream_notSet.nextTree());
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+ case 4 :
+ // org/antlr/grammar/v3/ANTLRv3.g:265:9: RULE_REF ( ARG_ACTION )? ( (op= '^' | op= '!' ) -> ^( $op RULE_REF ( ARG_ACTION )? ) | -> ^( RULE_REF ( ARG_ACTION )? ) )
+ {
+ RULE_REF110=(Token)match(input,RULE_REF,FOLLOW_RULE_REF_in_atom1903); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_RULE_REF.add(RULE_REF110);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:265:18: ( ARG_ACTION )?
+ int alt51=2;
+ int LA51_0 = input.LA(1);
+
+ if ( (LA51_0==ARG_ACTION) ) {
+ alt51=1;
+ }
+ switch (alt51) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:265:18: ARG_ACTION
+ {
+ ARG_ACTION111=(Token)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_atom1905); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ARG_ACTION.add(ARG_ACTION111);
+
+
+ }
+ break;
+
+ }
+
+ // org/antlr/grammar/v3/ANTLRv3.g:266:3: ( (op= '^' | op= '!' ) -> ^( $op RULE_REF ( ARG_ACTION )? ) | -> ^( RULE_REF ( ARG_ACTION )? ) )
+ int alt53=2;
+ int LA53_0 = input.LA(1);
+
+ if ( ((LA53_0>=ROOT && LA53_0<=BANG)) ) {
+ alt53=1;
+ }
+ else if ( (LA53_0==SEMPRED||LA53_0==TREE_BEGIN||LA53_0==REWRITE||(LA53_0>=TOKEN_REF && LA53_0<=ACTION)||LA53_0==RULE_REF||LA53_0==71||LA53_0==74||(LA53_0>=81 && LA53_0<=83)||LA53_0==87||(LA53_0>=90 && LA53_0<=92)) ) {
+ alt53=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 53, 0, input);
+
+ throw nvae;
+ }
+ switch (alt53) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:266:5: (op= '^' | op= '!' )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:266:5: (op= '^' | op= '!' )
+ int alt52=2;
+ int LA52_0 = input.LA(1);
+
+ if ( (LA52_0==ROOT) ) {
+ alt52=1;
+ }
+ else if ( (LA52_0==BANG) ) {
+ alt52=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 52, 0, input);
+
+ throw nvae;
+ }
+ switch (alt52) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:266:6: op= '^'
+ {
+ op=(Token)match(input,ROOT,FOLLOW_ROOT_in_atom1915); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ROOT.add(op);
+
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:266:13: op= '!'
+ {
+ op=(Token)match(input,BANG,FOLLOW_BANG_in_atom1919); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_BANG.add(op);
+
+
+ }
+ break;
+
+ }
+
+
+
+ // AST REWRITE
+ // elements: RULE_REF, ARG_ACTION, op
+ // token labels: op
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleTokenStream stream_op=new RewriteRuleTokenStream(adaptor,"token op",op);
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 266:21: -> ^( $op RULE_REF ( ARG_ACTION )? )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:266:24: ^( $op RULE_REF ( ARG_ACTION )? )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_op.nextNode(), root_1);
+
+ adaptor.addChild(root_1, stream_RULE_REF.nextNode());
+ // org/antlr/grammar/v3/ANTLRv3.g:266:39: ( ARG_ACTION )?
+ if ( stream_ARG_ACTION.hasNext() ) {
+ adaptor.addChild(root_1, stream_ARG_ACTION.nextNode());
+
+ }
+ stream_ARG_ACTION.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:267:9:
+ {
+
+ // AST REWRITE
+ // elements: ARG_ACTION, RULE_REF
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 267:9: -> ^( RULE_REF ( ARG_ACTION )? )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:267:12: ^( RULE_REF ( ARG_ACTION )? )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_RULE_REF.nextNode(), root_1);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:267:23: ( ARG_ACTION )?
+ if ( stream_ARG_ACTION.hasNext() ) {
+ adaptor.addChild(root_1, stream_ARG_ACTION.nextNode());
+
+ }
+ stream_ARG_ACTION.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+
+ }
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "atom"
+
+ public static class notSet_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "notSet"
+ // org/antlr/grammar/v3/ANTLRv3.g:271:1: notSet : '~' ( notTerminal ( elementOptions )? -> ^( '~' notTerminal ( elementOptions )? ) | block ( elementOptions )? -> ^( '~' block ( elementOptions )? ) ) ;
+ public final ANTLRv3Parser.notSet_return notSet() throws RecognitionException {
+ ANTLRv3Parser.notSet_return retval = new ANTLRv3Parser.notSet_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token char_literal112=null;
+ ANTLRv3Parser.notTerminal_return notTerminal113 = null;
+
+ ANTLRv3Parser.elementOptions_return elementOptions114 = null;
+
+ ANTLRv3Parser.block_return block115 = null;
+
+ ANTLRv3Parser.elementOptions_return elementOptions116 = null;
+
+
+ CommonTree char_literal112_tree=null;
+ RewriteRuleTokenStream stream_87=new RewriteRuleTokenStream(adaptor,"token 87");
+ RewriteRuleSubtreeStream stream_notTerminal=new RewriteRuleSubtreeStream(adaptor,"rule notTerminal");
+ RewriteRuleSubtreeStream stream_elementOptions=new RewriteRuleSubtreeStream(adaptor,"rule elementOptions");
+ RewriteRuleSubtreeStream stream_block=new RewriteRuleSubtreeStream(adaptor,"rule block");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:272:2: ( '~' ( notTerminal ( elementOptions )? -> ^( '~' notTerminal ( elementOptions )? ) | block ( elementOptions )? -> ^( '~' block ( elementOptions )? ) ) )
+ // org/antlr/grammar/v3/ANTLRv3.g:272:4: '~' ( notTerminal ( elementOptions )? -> ^( '~' notTerminal ( elementOptions )? ) | block ( elementOptions )? -> ^( '~' block ( elementOptions )? ) )
+ {
+ char_literal112=(Token)match(input,87,FOLLOW_87_in_notSet1967); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_87.add(char_literal112);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:273:3: ( notTerminal ( elementOptions )? -> ^( '~' notTerminal ( elementOptions )? ) | block ( elementOptions )? -> ^( '~' block ( elementOptions )? ) )
+ int alt57=2;
+ int LA57_0 = input.LA(1);
+
+ if ( ((LA57_0>=TOKEN_REF && LA57_0<=CHAR_LITERAL)) ) {
+ alt57=1;
+ }
+ else if ( (LA57_0==81) ) {
+ alt57=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 57, 0, input);
+
+ throw nvae;
+ }
+ switch (alt57) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:273:5: notTerminal ( elementOptions )?
+ {
+ pushFollow(FOLLOW_notTerminal_in_notSet1973);
+ notTerminal113=notTerminal();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_notTerminal.add(notTerminal113.getTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:273:17: ( elementOptions )?
+ int alt55=2;
+ int LA55_0 = input.LA(1);
+
+ if ( (LA55_0==88) ) {
+ alt55=1;
+ }
+ switch (alt55) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:273:17: elementOptions
+ {
+ pushFollow(FOLLOW_elementOptions_in_notSet1975);
+ elementOptions114=elementOptions();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_elementOptions.add(elementOptions114.getTree());
+
+ }
+ break;
+
+ }
+
+
+
+ // AST REWRITE
+ // elements: notTerminal, 87, elementOptions
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 273:33: -> ^( '~' notTerminal ( elementOptions )? )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:273:36: ^( '~' notTerminal ( elementOptions )? )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_87.nextNode(), root_1);
+
+ adaptor.addChild(root_1, stream_notTerminal.nextTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:273:54: ( elementOptions )?
+ if ( stream_elementOptions.hasNext() ) {
+ adaptor.addChild(root_1, stream_elementOptions.nextTree());
+
+ }
+ stream_elementOptions.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:274:5: block ( elementOptions )?
+ {
+ pushFollow(FOLLOW_block_in_notSet1993);
+ block115=block();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_block.add(block115.getTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:274:11: ( elementOptions )?
+ int alt56=2;
+ int LA56_0 = input.LA(1);
+
+ if ( (LA56_0==88) ) {
+ alt56=1;
+ }
+ switch (alt56) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:274:11: elementOptions
+ {
+ pushFollow(FOLLOW_elementOptions_in_notSet1995);
+ elementOptions116=elementOptions();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_elementOptions.add(elementOptions116.getTree());
+
+ }
+ break;
+
+ }
+
+
+
+ // AST REWRITE
+ // elements: 87, elementOptions, block
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 274:28: -> ^( '~' block ( elementOptions )? )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:274:31: ^( '~' block ( elementOptions )? )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_87.nextNode(), root_1);
+
+ adaptor.addChild(root_1, stream_block.nextTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:274:43: ( elementOptions )?
+ if ( stream_elementOptions.hasNext() ) {
+ adaptor.addChild(root_1, stream_elementOptions.nextTree());
+
+ }
+ stream_elementOptions.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+
+ }
+
+
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "notSet"
+
+ public static class notTerminal_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "notTerminal"
+ // org/antlr/grammar/v3/ANTLRv3.g:278:1: notTerminal : ( CHAR_LITERAL | TOKEN_REF | STRING_LITERAL );
+ public final ANTLRv3Parser.notTerminal_return notTerminal() throws RecognitionException {
+ ANTLRv3Parser.notTerminal_return retval = new ANTLRv3Parser.notTerminal_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token set117=null;
+
+ CommonTree set117_tree=null;
+
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:279:2: ( CHAR_LITERAL | TOKEN_REF | STRING_LITERAL )
+ // org/antlr/grammar/v3/ANTLRv3.g:
+ {
+ root_0 = (CommonTree)adaptor.nil();
+
+ set117=(Token)input.LT(1);
+ if ( (input.LA(1)>=TOKEN_REF && input.LA(1)<=CHAR_LITERAL) ) {
+ input.consume();
+ if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set117));
+ state.errorRecovery=false;state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ throw mse;
+ }
+
+
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "notTerminal"
+
+ public static class elementOptions_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "elementOptions"
+ // org/antlr/grammar/v3/ANTLRv3.g:284:1: elementOptions : ( '<' qid '>' -> ^( OPTIONS qid ) | '<' option ( ';' option )* '>' -> ^( OPTIONS ( option )+ ) );
+ public final ANTLRv3Parser.elementOptions_return elementOptions() throws RecognitionException {
+ ANTLRv3Parser.elementOptions_return retval = new ANTLRv3Parser.elementOptions_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token char_literal118=null;
+ Token char_literal120=null;
+ Token char_literal121=null;
+ Token char_literal123=null;
+ Token char_literal125=null;
+ ANTLRv3Parser.qid_return qid119 = null;
+
+ ANTLRv3Parser.option_return option122 = null;
+
+ ANTLRv3Parser.option_return option124 = null;
+
+
+ CommonTree char_literal118_tree=null;
+ CommonTree char_literal120_tree=null;
+ CommonTree char_literal121_tree=null;
+ CommonTree char_literal123_tree=null;
+ CommonTree char_literal125_tree=null;
+ RewriteRuleTokenStream stream_71=new RewriteRuleTokenStream(adaptor,"token 71");
+ RewriteRuleTokenStream stream_88=new RewriteRuleTokenStream(adaptor,"token 88");
+ RewriteRuleTokenStream stream_89=new RewriteRuleTokenStream(adaptor,"token 89");
+ RewriteRuleSubtreeStream stream_qid=new RewriteRuleSubtreeStream(adaptor,"rule qid");
+ RewriteRuleSubtreeStream stream_option=new RewriteRuleSubtreeStream(adaptor,"rule option");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:285:2: ( '<' qid '>' -> ^( OPTIONS qid ) | '<' option ( ';' option )* '>' -> ^( OPTIONS ( option )+ ) )
+ int alt59=2;
+ int LA59_0 = input.LA(1);
+
+ if ( (LA59_0==88) ) {
+ int LA59_1 = input.LA(2);
+
+ if ( (LA59_1==TOKEN_REF) ) {
+ int LA59_2 = input.LA(3);
+
+ if ( ((LA59_2>=89 && LA59_2<=90)) ) {
+ alt59=1;
+ }
+ else if ( (LA59_2==LABEL_ASSIGN) ) {
+ alt59=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 59, 2, input);
+
+ throw nvae;
+ }
+ }
+ else if ( (LA59_1==RULE_REF) ) {
+ int LA59_3 = input.LA(3);
+
+ if ( ((LA59_3>=89 && LA59_3<=90)) ) {
+ alt59=1;
+ }
+ else if ( (LA59_3==LABEL_ASSIGN) ) {
+ alt59=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 59, 3, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 59, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 59, 0, input);
+
+ throw nvae;
+ }
+ switch (alt59) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:285:4: '<' qid '>'
+ {
+ char_literal118=(Token)match(input,88,FOLLOW_88_in_elementOptions2047); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_88.add(char_literal118);
+
+ pushFollow(FOLLOW_qid_in_elementOptions2049);
+ qid119=qid();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_qid.add(qid119.getTree());
+ char_literal120=(Token)match(input,89,FOLLOW_89_in_elementOptions2051); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_89.add(char_literal120);
+
+
+
+ // AST REWRITE
+ // elements: qid
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 285:21: -> ^( OPTIONS qid )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:285:24: ^( OPTIONS qid )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(OPTIONS, "OPTIONS"), root_1);
+
+ adaptor.addChild(root_1, stream_qid.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:286:4: '<' option ( ';' option )* '>'
+ {
+ char_literal121=(Token)match(input,88,FOLLOW_88_in_elementOptions2069); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_88.add(char_literal121);
+
+ pushFollow(FOLLOW_option_in_elementOptions2071);
+ option122=option();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_option.add(option122.getTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:286:15: ( ';' option )*
+ loop58:
+ do {
+ int alt58=2;
+ int LA58_0 = input.LA(1);
+
+ if ( (LA58_0==71) ) {
+ alt58=1;
+ }
+
+
+ switch (alt58) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:286:16: ';' option
+ {
+ char_literal123=(Token)match(input,71,FOLLOW_71_in_elementOptions2074); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_71.add(char_literal123);
+
+ pushFollow(FOLLOW_option_in_elementOptions2076);
+ option124=option();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_option.add(option124.getTree());
+
+ }
+ break;
+
+ default :
+ break loop58;
+ }
+ } while (true);
+
+ char_literal125=(Token)match(input,89,FOLLOW_89_in_elementOptions2080); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_89.add(char_literal125);
+
+
+
+ // AST REWRITE
+ // elements: option
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 286:33: -> ^( OPTIONS ( option )+ )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:286:36: ^( OPTIONS ( option )+ )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(OPTIONS, "OPTIONS"), root_1);
+
+ if ( !(stream_option.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_option.hasNext() ) {
+ adaptor.addChild(root_1, stream_option.nextTree());
+
+ }
+ stream_option.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+
+ }
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "elementOptions"
+
+ public static class elementOption_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "elementOption"
+ // org/antlr/grammar/v3/ANTLRv3.g:289:1: elementOption : id '=' optionValue -> ^( '=' id optionValue ) ;
+ public final ANTLRv3Parser.elementOption_return elementOption() throws RecognitionException {
+ ANTLRv3Parser.elementOption_return retval = new ANTLRv3Parser.elementOption_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token char_literal127=null;
+ ANTLRv3Parser.id_return id126 = null;
+
+ ANTLRv3Parser.optionValue_return optionValue128 = null;
+
+
+ CommonTree char_literal127_tree=null;
+ RewriteRuleTokenStream stream_LABEL_ASSIGN=new RewriteRuleTokenStream(adaptor,"token LABEL_ASSIGN");
+ RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
+ RewriteRuleSubtreeStream stream_optionValue=new RewriteRuleSubtreeStream(adaptor,"rule optionValue");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:290:2: ( id '=' optionValue -> ^( '=' id optionValue ) )
+ // org/antlr/grammar/v3/ANTLRv3.g:290:4: id '=' optionValue
+ {
+ pushFollow(FOLLOW_id_in_elementOption2100);
+ id126=id();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_id.add(id126.getTree());
+ char_literal127=(Token)match(input,LABEL_ASSIGN,FOLLOW_LABEL_ASSIGN_in_elementOption2102); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_LABEL_ASSIGN.add(char_literal127);
+
+ pushFollow(FOLLOW_optionValue_in_elementOption2104);
+ optionValue128=optionValue();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_optionValue.add(optionValue128.getTree());
+
+
+ // AST REWRITE
+ // elements: LABEL_ASSIGN, id, optionValue
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 290:23: -> ^( '=' id optionValue )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:290:26: ^( '=' id optionValue )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_LABEL_ASSIGN.nextNode(), root_1);
+
+ adaptor.addChild(root_1, stream_id.nextTree());
+ adaptor.addChild(root_1, stream_optionValue.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "elementOption"
+
+ public static class treeSpec_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "treeSpec"
+ // org/antlr/grammar/v3/ANTLRv3.g:293:1: treeSpec : '^(' element ( element )+ ')' -> ^( TREE_BEGIN ( element )+ ) ;
+ public final ANTLRv3Parser.treeSpec_return treeSpec() throws RecognitionException {
+ ANTLRv3Parser.treeSpec_return retval = new ANTLRv3Parser.treeSpec_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token string_literal129=null;
+ Token char_literal132=null;
+ ANTLRv3Parser.element_return element130 = null;
+
+ ANTLRv3Parser.element_return element131 = null;
+
+
+ CommonTree string_literal129_tree=null;
+ CommonTree char_literal132_tree=null;
+ RewriteRuleTokenStream stream_83=new RewriteRuleTokenStream(adaptor,"token 83");
+ RewriteRuleTokenStream stream_TREE_BEGIN=new RewriteRuleTokenStream(adaptor,"token TREE_BEGIN");
+ RewriteRuleSubtreeStream stream_element=new RewriteRuleSubtreeStream(adaptor,"rule element");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:294:2: ( '^(' element ( element )+ ')' -> ^( TREE_BEGIN ( element )+ ) )
+ // org/antlr/grammar/v3/ANTLRv3.g:294:4: '^(' element ( element )+ ')'
+ {
+ string_literal129=(Token)match(input,TREE_BEGIN,FOLLOW_TREE_BEGIN_in_treeSpec2126); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_TREE_BEGIN.add(string_literal129);
+
+ pushFollow(FOLLOW_element_in_treeSpec2128);
+ element130=element();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_element.add(element130.getTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:294:17: ( element )+
+ int cnt60=0;
+ loop60:
+ do {
+ int alt60=2;
+ int LA60_0 = input.LA(1);
+
+ if ( (LA60_0==SEMPRED||LA60_0==TREE_BEGIN||(LA60_0>=TOKEN_REF && LA60_0<=ACTION)||LA60_0==RULE_REF||LA60_0==81||LA60_0==87||LA60_0==90) ) {
+ alt60=1;
+ }
+
+
+ switch (alt60) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:294:19: element
+ {
+ pushFollow(FOLLOW_element_in_treeSpec2132);
+ element131=element();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_element.add(element131.getTree());
+
+ }
+ break;
+
+ default :
+ if ( cnt60 >= 1 ) break loop60;
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ EarlyExitException eee =
+ new EarlyExitException(60, input);
+ throw eee;
+ }
+ cnt60++;
+ } while (true);
+
+ char_literal132=(Token)match(input,83,FOLLOW_83_in_treeSpec2137); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_83.add(char_literal132);
+
+
+
+ // AST REWRITE
+ // elements: element
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 294:34: -> ^( TREE_BEGIN ( element )+ )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:294:37: ^( TREE_BEGIN ( element )+ )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TREE_BEGIN, "TREE_BEGIN"), root_1);
+
+ if ( !(stream_element.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_element.hasNext() ) {
+ adaptor.addChild(root_1, stream_element.nextTree());
+
+ }
+ stream_element.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "treeSpec"
+
+ public static class range_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "range"
+ // org/antlr/grammar/v3/ANTLRv3.g:297:1: range : c1= CHAR_LITERAL RANGE c2= CHAR_LITERAL ( elementOptions )? -> ^( CHAR_RANGE[$c1,\"..\"] $c1 $c2 ( elementOptions )? ) ;
+ public final ANTLRv3Parser.range_return range() throws RecognitionException {
+ ANTLRv3Parser.range_return retval = new ANTLRv3Parser.range_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token c1=null;
+ Token c2=null;
+ Token RANGE133=null;
+ ANTLRv3Parser.elementOptions_return elementOptions134 = null;
+
+
+ CommonTree c1_tree=null;
+ CommonTree c2_tree=null;
+ CommonTree RANGE133_tree=null;
+ RewriteRuleTokenStream stream_RANGE=new RewriteRuleTokenStream(adaptor,"token RANGE");
+ RewriteRuleTokenStream stream_CHAR_LITERAL=new RewriteRuleTokenStream(adaptor,"token CHAR_LITERAL");
+ RewriteRuleSubtreeStream stream_elementOptions=new RewriteRuleSubtreeStream(adaptor,"rule elementOptions");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:298:2: (c1= CHAR_LITERAL RANGE c2= CHAR_LITERAL ( elementOptions )? -> ^( CHAR_RANGE[$c1,\"..\"] $c1 $c2 ( elementOptions )? ) )
+ // org/antlr/grammar/v3/ANTLRv3.g:298:4: c1= CHAR_LITERAL RANGE c2= CHAR_LITERAL ( elementOptions )?
+ {
+ c1=(Token)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_range2160); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_CHAR_LITERAL.add(c1);
+
+ RANGE133=(Token)match(input,RANGE,FOLLOW_RANGE_in_range2162); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_RANGE.add(RANGE133);
+
+ c2=(Token)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_range2166); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_CHAR_LITERAL.add(c2);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:298:42: ( elementOptions )?
+ int alt61=2;
+ int LA61_0 = input.LA(1);
+
+ if ( (LA61_0==88) ) {
+ alt61=1;
+ }
+ switch (alt61) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:298:42: elementOptions
+ {
+ pushFollow(FOLLOW_elementOptions_in_range2168);
+ elementOptions134=elementOptions();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_elementOptions.add(elementOptions134.getTree());
+
+ }
+ break;
+
+ }
+
+
+
+ // AST REWRITE
+ // elements: c2, c1, elementOptions
+ // token labels: c1, c2
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleTokenStream stream_c1=new RewriteRuleTokenStream(adaptor,"token c1",c1);
+ RewriteRuleTokenStream stream_c2=new RewriteRuleTokenStream(adaptor,"token c2",c2);
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 299:3: -> ^( CHAR_RANGE[$c1,\"..\"] $c1 $c2 ( elementOptions )? )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:299:6: ^( CHAR_RANGE[$c1,\"..\"] $c1 $c2 ( elementOptions )? )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(CHAR_RANGE, c1, ".."), root_1);
+
+ adaptor.addChild(root_1, stream_c1.nextNode());
+ adaptor.addChild(root_1, stream_c2.nextNode());
+ // org/antlr/grammar/v3/ANTLRv3.g:299:37: ( elementOptions )?
+ if ( stream_elementOptions.hasNext() ) {
+ adaptor.addChild(root_1, stream_elementOptions.nextTree());
+
+ }
+ stream_elementOptions.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "range"
+
+ public static class terminal_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "terminal"
+ // org/antlr/grammar/v3/ANTLRv3.g:302:1: terminal : ( CHAR_LITERAL ( elementOptions )? -> ^( CHAR_LITERAL ( elementOptions )? ) | TOKEN_REF ( ARG_ACTION )? ( elementOptions )? -> ^( TOKEN_REF ( ARG_ACTION )? ( elementOptions )? ) | STRING_LITERAL ( elementOptions )? -> ^( STRING_LITERAL ( elementOptions )? ) | '.' ( elementOptions )? -> ^( '.' ( elementOptions )? ) ) ( '^' -> ^( '^' $terminal) | '!' -> ^( '!' $terminal) )? ;
+ public final ANTLRv3Parser.terminal_return terminal() throws RecognitionException {
+ ANTLRv3Parser.terminal_return retval = new ANTLRv3Parser.terminal_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token CHAR_LITERAL135=null;
+ Token TOKEN_REF137=null;
+ Token ARG_ACTION138=null;
+ Token STRING_LITERAL140=null;
+ Token char_literal142=null;
+ Token char_literal144=null;
+ Token char_literal145=null;
+ ANTLRv3Parser.elementOptions_return elementOptions136 = null;
+
+ ANTLRv3Parser.elementOptions_return elementOptions139 = null;
+
+ ANTLRv3Parser.elementOptions_return elementOptions141 = null;
+
+ ANTLRv3Parser.elementOptions_return elementOptions143 = null;
+
+
+ CommonTree CHAR_LITERAL135_tree=null;
+ CommonTree TOKEN_REF137_tree=null;
+ CommonTree ARG_ACTION138_tree=null;
+ CommonTree STRING_LITERAL140_tree=null;
+ CommonTree char_literal142_tree=null;
+ CommonTree char_literal144_tree=null;
+ CommonTree char_literal145_tree=null;
+ RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL");
+ RewriteRuleTokenStream stream_BANG=new RewriteRuleTokenStream(adaptor,"token BANG");
+ RewriteRuleTokenStream stream_CHAR_LITERAL=new RewriteRuleTokenStream(adaptor,"token CHAR_LITERAL");
+ RewriteRuleTokenStream stream_90=new RewriteRuleTokenStream(adaptor,"token 90");
+ RewriteRuleTokenStream stream_ROOT=new RewriteRuleTokenStream(adaptor,"token ROOT");
+ RewriteRuleTokenStream stream_TOKEN_REF=new RewriteRuleTokenStream(adaptor,"token TOKEN_REF");
+ RewriteRuleTokenStream stream_ARG_ACTION=new RewriteRuleTokenStream(adaptor,"token ARG_ACTION");
+ RewriteRuleSubtreeStream stream_elementOptions=new RewriteRuleSubtreeStream(adaptor,"rule elementOptions");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:303:5: ( ( CHAR_LITERAL ( elementOptions )? -> ^( CHAR_LITERAL ( elementOptions )? ) | TOKEN_REF ( ARG_ACTION )? ( elementOptions )? -> ^( TOKEN_REF ( ARG_ACTION )? ( elementOptions )? ) | STRING_LITERAL ( elementOptions )? -> ^( STRING_LITERAL ( elementOptions )? ) | '.' ( elementOptions )? -> ^( '.' ( elementOptions )? ) ) ( '^' -> ^( '^' $terminal) | '!' -> ^( '!' $terminal) )? )
+ // org/antlr/grammar/v3/ANTLRv3.g:303:9: ( CHAR_LITERAL ( elementOptions )? -> ^( CHAR_LITERAL ( elementOptions )? ) | TOKEN_REF ( ARG_ACTION )? ( elementOptions )? -> ^( TOKEN_REF ( ARG_ACTION )? ( elementOptions )? ) | STRING_LITERAL ( elementOptions )? -> ^( STRING_LITERAL ( elementOptions )? ) | '.' ( elementOptions )? -> ^( '.' ( elementOptions )? ) ) ( '^' -> ^( '^' $terminal) | '!' -> ^( '!' $terminal) )?
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:303:9: ( CHAR_LITERAL ( elementOptions )? -> ^( CHAR_LITERAL ( elementOptions )? ) | TOKEN_REF ( ARG_ACTION )? ( elementOptions )? -> ^( TOKEN_REF ( ARG_ACTION )? ( elementOptions )? ) | STRING_LITERAL ( elementOptions )? -> ^( STRING_LITERAL ( elementOptions )? ) | '.' ( elementOptions )? -> ^( '.' ( elementOptions )? ) )
+ int alt67=4;
+ switch ( input.LA(1) ) {
+ case CHAR_LITERAL:
+ {
+ alt67=1;
+ }
+ break;
+ case TOKEN_REF:
+ {
+ alt67=2;
+ }
+ break;
+ case STRING_LITERAL:
+ {
+ alt67=3;
+ }
+ break;
+ case 90:
+ {
+ alt67=4;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 67, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt67) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:303:11: CHAR_LITERAL ( elementOptions )?
+ {
+ CHAR_LITERAL135=(Token)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_terminal2205); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_CHAR_LITERAL.add(CHAR_LITERAL135);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:303:24: ( elementOptions )?
+ int alt62=2;
+ int LA62_0 = input.LA(1);
+
+ if ( (LA62_0==88) ) {
+ alt62=1;
+ }
+ switch (alt62) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:303:24: elementOptions
+ {
+ pushFollow(FOLLOW_elementOptions_in_terminal2207);
+ elementOptions136=elementOptions();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_elementOptions.add(elementOptions136.getTree());
+
+ }
+ break;
+
+ }
+
+
+
+ // AST REWRITE
+ // elements: CHAR_LITERAL, elementOptions
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 303:46: -> ^( CHAR_LITERAL ( elementOptions )? )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:303:49: ^( CHAR_LITERAL ( elementOptions )? )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_CHAR_LITERAL.nextNode(), root_1);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:303:64: ( elementOptions )?
+ if ( stream_elementOptions.hasNext() ) {
+ adaptor.addChild(root_1, stream_elementOptions.nextTree());
+
+ }
+ stream_elementOptions.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:305:7: TOKEN_REF ( ARG_ACTION )? ( elementOptions )?
+ {
+ TOKEN_REF137=(Token)match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_terminal2238); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_TOKEN_REF.add(TOKEN_REF137);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:305:17: ( ARG_ACTION )?
+ int alt63=2;
+ int LA63_0 = input.LA(1);
+
+ if ( (LA63_0==ARG_ACTION) ) {
+ alt63=1;
+ }
+ switch (alt63) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:305:17: ARG_ACTION
+ {
+ ARG_ACTION138=(Token)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_terminal2240); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ARG_ACTION.add(ARG_ACTION138);
+
+
+ }
+ break;
+
+ }
+
+ // org/antlr/grammar/v3/ANTLRv3.g:305:29: ( elementOptions )?
+ int alt64=2;
+ int LA64_0 = input.LA(1);
+
+ if ( (LA64_0==88) ) {
+ alt64=1;
+ }
+ switch (alt64) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:305:29: elementOptions
+ {
+ pushFollow(FOLLOW_elementOptions_in_terminal2243);
+ elementOptions139=elementOptions();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_elementOptions.add(elementOptions139.getTree());
+
+ }
+ break;
+
+ }
+
+
+
+ // AST REWRITE
+ // elements: elementOptions, TOKEN_REF, ARG_ACTION
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 305:45: -> ^( TOKEN_REF ( ARG_ACTION )? ( elementOptions )? )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:305:48: ^( TOKEN_REF ( ARG_ACTION )? ( elementOptions )? )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_TOKEN_REF.nextNode(), root_1);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:305:60: ( ARG_ACTION )?
+ if ( stream_ARG_ACTION.hasNext() ) {
+ adaptor.addChild(root_1, stream_ARG_ACTION.nextNode());
+
+ }
+ stream_ARG_ACTION.reset();
+ // org/antlr/grammar/v3/ANTLRv3.g:305:72: ( elementOptions )?
+ if ( stream_elementOptions.hasNext() ) {
+ adaptor.addChild(root_1, stream_elementOptions.nextTree());
+
+ }
+ stream_elementOptions.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3.g:306:7: STRING_LITERAL ( elementOptions )?
+ {
+ STRING_LITERAL140=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_terminal2264); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_STRING_LITERAL.add(STRING_LITERAL140);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:306:22: ( elementOptions )?
+ int alt65=2;
+ int LA65_0 = input.LA(1);
+
+ if ( (LA65_0==88) ) {
+ alt65=1;
+ }
+ switch (alt65) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:306:22: elementOptions
+ {
+ pushFollow(FOLLOW_elementOptions_in_terminal2266);
+ elementOptions141=elementOptions();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_elementOptions.add(elementOptions141.getTree());
+
+ }
+ break;
+
+ }
+
+
+
+ // AST REWRITE
+ // elements: STRING_LITERAL, elementOptions
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 306:41: -> ^( STRING_LITERAL ( elementOptions )? )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:306:44: ^( STRING_LITERAL ( elementOptions )? )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_STRING_LITERAL.nextNode(), root_1);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:306:61: ( elementOptions )?
+ if ( stream_elementOptions.hasNext() ) {
+ adaptor.addChild(root_1, stream_elementOptions.nextTree());
+
+ }
+ stream_elementOptions.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 4 :
+ // org/antlr/grammar/v3/ANTLRv3.g:307:7: '.' ( elementOptions )?
+ {
+ char_literal142=(Token)match(input,90,FOLLOW_90_in_terminal2287); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_90.add(char_literal142);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:307:11: ( elementOptions )?
+ int alt66=2;
+ int LA66_0 = input.LA(1);
+
+ if ( (LA66_0==88) ) {
+ alt66=1;
+ }
+ switch (alt66) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:307:11: elementOptions
+ {
+ pushFollow(FOLLOW_elementOptions_in_terminal2289);
+ elementOptions143=elementOptions();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_elementOptions.add(elementOptions143.getTree());
+
+ }
+ break;
+
+ }
+
+
+
+ // AST REWRITE
+ // elements: elementOptions, 90
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 307:34: -> ^( '.' ( elementOptions )? )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:307:37: ^( '.' ( elementOptions )? )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_90.nextNode(), root_1);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:307:43: ( elementOptions )?
+ if ( stream_elementOptions.hasNext() ) {
+ adaptor.addChild(root_1, stream_elementOptions.nextTree());
+
+ }
+ stream_elementOptions.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+
+ }
+
+ // org/antlr/grammar/v3/ANTLRv3.g:309:3: ( '^' -> ^( '^' $terminal) | '!' -> ^( '!' $terminal) )?
+ int alt68=3;
+ int LA68_0 = input.LA(1);
+
+ if ( (LA68_0==ROOT) ) {
+ alt68=1;
+ }
+ else if ( (LA68_0==BANG) ) {
+ alt68=2;
+ }
+ switch (alt68) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:309:5: '^'
+ {
+ char_literal144=(Token)match(input,ROOT,FOLLOW_ROOT_in_terminal2316); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ROOT.add(char_literal144);
+
+
+
+ // AST REWRITE
+ // elements: ROOT, terminal
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 309:15: -> ^( '^' $terminal)
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:309:18: ^( '^' $terminal)
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_ROOT.nextNode(), root_1);
+
+ adaptor.addChild(root_1, stream_retval.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:310:5: '!'
+ {
+ char_literal145=(Token)match(input,BANG,FOLLOW_BANG_in_terminal2337); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_BANG.add(char_literal145);
+
+
+
+ // AST REWRITE
+ // elements: BANG, terminal
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 310:15: -> ^( '!' $terminal)
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:310:18: ^( '!' $terminal)
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_BANG.nextNode(), root_1);
+
+ adaptor.addChild(root_1, stream_retval.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+
+ }
+
+
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "terminal"
+
+ public static class ebnf_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "ebnf"
+ // org/antlr/grammar/v3/ANTLRv3.g:314:1: ebnf : block (op= '?' -> ^( OPTIONAL[op] block ) | op= '*' -> ^( CLOSURE[op] block ) | op= '+' -> ^( POSITIVE_CLOSURE[op] block ) | '=>' -> {gtype==COMBINED_GRAMMAR &&\n\t\t\t\t\t Character.isUpperCase($rule::name.charAt(0))}? ^( SYNPRED[\"=>\"] block ) -> SYN_SEMPRED | -> block ) ;
+ public final ANTLRv3Parser.ebnf_return ebnf() throws RecognitionException {
+ ANTLRv3Parser.ebnf_return retval = new ANTLRv3Parser.ebnf_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token op=null;
+ Token string_literal147=null;
+ ANTLRv3Parser.block_return block146 = null;
+
+
+ CommonTree op_tree=null;
+ CommonTree string_literal147_tree=null;
+ RewriteRuleTokenStream stream_92=new RewriteRuleTokenStream(adaptor,"token 92");
+ RewriteRuleTokenStream stream_91=new RewriteRuleTokenStream(adaptor,"token 91");
+ RewriteRuleTokenStream stream_86=new RewriteRuleTokenStream(adaptor,"token 86");
+ RewriteRuleTokenStream stream_74=new RewriteRuleTokenStream(adaptor,"token 74");
+ RewriteRuleSubtreeStream stream_block=new RewriteRuleSubtreeStream(adaptor,"rule block");
+
+ Token firstToken = input.LT(1);
+
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:323:2: ( block (op= '?' -> ^( OPTIONAL[op] block ) | op= '*' -> ^( CLOSURE[op] block ) | op= '+' -> ^( POSITIVE_CLOSURE[op] block ) | '=>' -> {gtype==COMBINED_GRAMMAR &&\n\t\t\t\t\t Character.isUpperCase($rule::name.charAt(0))}? ^( SYNPRED[\"=>\"] block ) -> SYN_SEMPRED | -> block ) )
+ // org/antlr/grammar/v3/ANTLRv3.g:323:4: block (op= '?' -> ^( OPTIONAL[op] block ) | op= '*' -> ^( CLOSURE[op] block ) | op= '+' -> ^( POSITIVE_CLOSURE[op] block ) | '=>' -> {gtype==COMBINED_GRAMMAR &&\n\t\t\t\t\t Character.isUpperCase($rule::name.charAt(0))}? ^( SYNPRED[\"=>\"] block ) -> SYN_SEMPRED | -> block )
+ {
+ pushFollow(FOLLOW_block_in_ebnf2380);
+ block146=block();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_block.add(block146.getTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:324:3: (op= '?' -> ^( OPTIONAL[op] block ) | op= '*' -> ^( CLOSURE[op] block ) | op= '+' -> ^( POSITIVE_CLOSURE[op] block ) | '=>' -> {gtype==COMBINED_GRAMMAR &&\n\t\t\t\t\t Character.isUpperCase($rule::name.charAt(0))}? ^( SYNPRED[\"=>\"] block ) -> SYN_SEMPRED | -> block )
+ int alt69=5;
+ switch ( input.LA(1) ) {
+ case 91:
+ {
+ alt69=1;
+ }
+ break;
+ case 74:
+ {
+ alt69=2;
+ }
+ break;
+ case 92:
+ {
+ alt69=3;
+ }
+ break;
+ case 86:
+ {
+ alt69=4;
+ }
+ break;
+ case SEMPRED:
+ case TREE_BEGIN:
+ case REWRITE:
+ case TOKEN_REF:
+ case STRING_LITERAL:
+ case CHAR_LITERAL:
+ case ACTION:
+ case RULE_REF:
+ case 71:
+ case 81:
+ case 82:
+ case 83:
+ case 87:
+ case 90:
+ {
+ alt69=5;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 69, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt69) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:324:5: op= '?'
+ {
+ op=(Token)match(input,91,FOLLOW_91_in_ebnf2388); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_91.add(op);
+
+
+
+ // AST REWRITE
+ // elements: block
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 324:12: -> ^( OPTIONAL[op] block )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:324:15: ^( OPTIONAL[op] block )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(OPTIONAL, op), root_1);
+
+ adaptor.addChild(root_1, stream_block.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:325:5: op= '*'
+ {
+ op=(Token)match(input,74,FOLLOW_74_in_ebnf2405); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_74.add(op);
+
+
+
+ // AST REWRITE
+ // elements: block
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 325:12: -> ^( CLOSURE[op] block )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:325:15: ^( CLOSURE[op] block )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(CLOSURE, op), root_1);
+
+ adaptor.addChild(root_1, stream_block.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3.g:326:5: op= '+'
+ {
+ op=(Token)match(input,92,FOLLOW_92_in_ebnf2422); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_92.add(op);
+
+
+
+ // AST REWRITE
+ // elements: block
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 326:12: -> ^( POSITIVE_CLOSURE[op] block )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:326:15: ^( POSITIVE_CLOSURE[op] block )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(POSITIVE_CLOSURE, op), root_1);
+
+ adaptor.addChild(root_1, stream_block.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 4 :
+ // org/antlr/grammar/v3/ANTLRv3.g:327:7: '=>'
+ {
+ string_literal147=(Token)match(input,86,FOLLOW_86_in_ebnf2439); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_86.add(string_literal147);
+
+
+
+ // AST REWRITE
+ // elements: block
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 328:6: -> {gtype==COMBINED_GRAMMAR &&\n\t\t\t\t\t Character.isUpperCase($rule::name.charAt(0))}? ^( SYNPRED[\"=>\"] block )
+ if (gtype==COMBINED_GRAMMAR &&
+ Character.isUpperCase(((rule_scope)rule_stack.peek()).name.charAt(0))) {
+ // org/antlr/grammar/v3/ANTLRv3.g:331:9: ^( SYNPRED[\"=>\"] block )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(SYNPRED, "=>"), root_1);
+
+ adaptor.addChild(root_1, stream_block.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+ else // 333:6: -> SYN_SEMPRED
+ {
+ adaptor.addChild(root_0, (CommonTree)adaptor.create(SYN_SEMPRED, "SYN_SEMPRED"));
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 5 :
+ // org/antlr/grammar/v3/ANTLRv3.g:334:13:
+ {
+
+ // AST REWRITE
+ // elements: block
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 334:13: -> block
+ {
+ adaptor.addChild(root_0, stream_block.nextTree());
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+
+ }
+
+
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ if ( state.backtracking==0 ) {
+
+ ((CommonTree)retval.tree).getToken().setLine(firstToken.getLine());
+ ((CommonTree)retval.tree).getToken().setCharPositionInLine(firstToken.getCharPositionInLine());
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "ebnf"
+
+ public static class ebnfSuffix_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "ebnfSuffix"
+ // org/antlr/grammar/v3/ANTLRv3.g:338:1: ebnfSuffix : ( '?' -> OPTIONAL[op] | '*' -> CLOSURE[op] | '+' -> POSITIVE_CLOSURE[op] );
+ public final ANTLRv3Parser.ebnfSuffix_return ebnfSuffix() throws RecognitionException {
+ ANTLRv3Parser.ebnfSuffix_return retval = new ANTLRv3Parser.ebnfSuffix_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token char_literal148=null;
+ Token char_literal149=null;
+ Token char_literal150=null;
+
+ CommonTree char_literal148_tree=null;
+ CommonTree char_literal149_tree=null;
+ CommonTree char_literal150_tree=null;
+ RewriteRuleTokenStream stream_92=new RewriteRuleTokenStream(adaptor,"token 92");
+ RewriteRuleTokenStream stream_91=new RewriteRuleTokenStream(adaptor,"token 91");
+ RewriteRuleTokenStream stream_74=new RewriteRuleTokenStream(adaptor,"token 74");
+
+
+ Token op = input.LT(1);
+
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:342:2: ( '?' -> OPTIONAL[op] | '*' -> CLOSURE[op] | '+' -> POSITIVE_CLOSURE[op] )
+ int alt70=3;
+ switch ( input.LA(1) ) {
+ case 91:
+ {
+ alt70=1;
+ }
+ break;
+ case 74:
+ {
+ alt70=2;
+ }
+ break;
+ case 92:
+ {
+ alt70=3;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 70, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt70) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:342:4: '?'
+ {
+ char_literal148=(Token)match(input,91,FOLLOW_91_in_ebnfSuffix2524); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_91.add(char_literal148);
+
+
+
+ // AST REWRITE
+ // elements:
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 342:8: -> OPTIONAL[op]
+ {
+ adaptor.addChild(root_0, (CommonTree)adaptor.create(OPTIONAL, op));
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:343:6: '*'
+ {
+ char_literal149=(Token)match(input,74,FOLLOW_74_in_ebnfSuffix2536); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_74.add(char_literal149);
+
+
+
+ // AST REWRITE
+ // elements:
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 343:10: -> CLOSURE[op]
+ {
+ adaptor.addChild(root_0, (CommonTree)adaptor.create(CLOSURE, op));
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3.g:344:7: '+'
+ {
+ char_literal150=(Token)match(input,92,FOLLOW_92_in_ebnfSuffix2549); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_92.add(char_literal150);
+
+
+
+ // AST REWRITE
+ // elements:
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 344:11: -> POSITIVE_CLOSURE[op]
+ {
+ adaptor.addChild(root_0, (CommonTree)adaptor.create(POSITIVE_CLOSURE, op));
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+
+ }
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "ebnfSuffix"
+
+ public static class rewrite_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "rewrite"
+ // org/antlr/grammar/v3/ANTLRv3.g:351:1: rewrite : ( (rew+= '->' preds+= SEMPRED predicated+= rewrite_alternative )* rew2= '->' last= rewrite_alternative -> ( ^( $rew $preds $predicated) )* ^( $rew2 $last) | );
+ public final ANTLRv3Parser.rewrite_return rewrite() throws RecognitionException {
+ ANTLRv3Parser.rewrite_return retval = new ANTLRv3Parser.rewrite_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token rew2=null;
+ Token rew=null;
+ Token preds=null;
+ List list_rew=null;
+ List list_preds=null;
+ List list_predicated=null;
+ ANTLRv3Parser.rewrite_alternative_return last = null;
+
+ ANTLRv3Parser.rewrite_alternative_return predicated = null;
+ predicated = null;
+ CommonTree rew2_tree=null;
+ CommonTree rew_tree=null;
+ CommonTree preds_tree=null;
+ RewriteRuleTokenStream stream_SEMPRED=new RewriteRuleTokenStream(adaptor,"token SEMPRED");
+ RewriteRuleTokenStream stream_REWRITE=new RewriteRuleTokenStream(adaptor,"token REWRITE");
+ RewriteRuleSubtreeStream stream_rewrite_alternative=new RewriteRuleSubtreeStream(adaptor,"rule rewrite_alternative");
+
+ Token firstToken = input.LT(1);
+
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:355:2: ( (rew+= '->' preds+= SEMPRED predicated+= rewrite_alternative )* rew2= '->' last= rewrite_alternative -> ( ^( $rew $preds $predicated) )* ^( $rew2 $last) | )
+ int alt72=2;
+ int LA72_0 = input.LA(1);
+
+ if ( (LA72_0==REWRITE) ) {
+ alt72=1;
+ }
+ else if ( (LA72_0==71||(LA72_0>=82 && LA72_0<=83)) ) {
+ alt72=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 72, 0, input);
+
+ throw nvae;
+ }
+ switch (alt72) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:355:4: (rew+= '->' preds+= SEMPRED predicated+= rewrite_alternative )* rew2= '->' last= rewrite_alternative
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:355:4: (rew+= '->' preds+= SEMPRED predicated+= rewrite_alternative )*
+ loop71:
+ do {
+ int alt71=2;
+ int LA71_0 = input.LA(1);
+
+ if ( (LA71_0==REWRITE) ) {
+ int LA71_1 = input.LA(2);
+
+ if ( (LA71_1==SEMPRED) ) {
+ alt71=1;
+ }
+
+
+ }
+
+
+ switch (alt71) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:355:5: rew+= '->' preds+= SEMPRED predicated+= rewrite_alternative
+ {
+ rew=(Token)match(input,REWRITE,FOLLOW_REWRITE_in_rewrite2578); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_REWRITE.add(rew);
+
+ if (list_rew==null) list_rew=new ArrayList();
+ list_rew.add(rew);
+
+ preds=(Token)match(input,SEMPRED,FOLLOW_SEMPRED_in_rewrite2582); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_SEMPRED.add(preds);
+
+ if (list_preds==null) list_preds=new ArrayList();
+ list_preds.add(preds);
+
+ pushFollow(FOLLOW_rewrite_alternative_in_rewrite2586);
+ predicated=rewrite_alternative();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_rewrite_alternative.add(predicated.getTree());
+ if (list_predicated==null) list_predicated=new ArrayList();
+ list_predicated.add(predicated.getTree());
+
+
+ }
+ break;
+
+ default :
+ break loop71;
+ }
+ } while (true);
+
+ rew2=(Token)match(input,REWRITE,FOLLOW_REWRITE_in_rewrite2594); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_REWRITE.add(rew2);
+
+ pushFollow(FOLLOW_rewrite_alternative_in_rewrite2598);
+ last=rewrite_alternative();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_rewrite_alternative.add(last.getTree());
+
+
+ // AST REWRITE
+ // elements: predicated, rew, last, rew2, preds
+ // token labels: rew2
+ // rule labels: retval, last
+ // token list labels: rew, preds
+ // rule list labels: predicated
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleTokenStream stream_rew2=new RewriteRuleTokenStream(adaptor,"token rew2",rew2);
+ RewriteRuleTokenStream stream_rew=new RewriteRuleTokenStream(adaptor,"token rew", list_rew);
+ RewriteRuleTokenStream stream_preds=new RewriteRuleTokenStream(adaptor,"token preds", list_preds);
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+ RewriteRuleSubtreeStream stream_last=new RewriteRuleSubtreeStream(adaptor,"rule last",last!=null?last.tree:null);
+ RewriteRuleSubtreeStream stream_predicated=new RewriteRuleSubtreeStream(adaptor,"token predicated",list_predicated);
+ root_0 = (CommonTree)adaptor.nil();
+ // 357:9: -> ( ^( $rew $preds $predicated) )* ^( $rew2 $last)
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:357:12: ( ^( $rew $preds $predicated) )*
+ while ( stream_predicated.hasNext()||stream_rew.hasNext()||stream_preds.hasNext() ) {
+ // org/antlr/grammar/v3/ANTLRv3.g:357:12: ^( $rew $preds $predicated)
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_rew.nextNode(), root_1);
+
+ adaptor.addChild(root_1, stream_preds.nextNode());
+ adaptor.addChild(root_1, stream_predicated.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+ stream_predicated.reset();
+ stream_rew.reset();
+ stream_preds.reset();
+ // org/antlr/grammar/v3/ANTLRv3.g:357:40: ^( $rew2 $last)
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_rew2.nextNode(), root_1);
+
+ adaptor.addChild(root_1, stream_last.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:359:2:
+ {
+ root_0 = (CommonTree)adaptor.nil();
+
+ }
+ break;
+
+ }
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "rewrite"
+
+ public static class rewrite_alternative_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "rewrite_alternative"
+ // org/antlr/grammar/v3/ANTLRv3.g:361:1: rewrite_alternative options {backtrack=true; } : ( rewrite_template | rewrite_tree_alternative | -> ^( ALT[\"ALT\"] EPSILON[\"EPSILON\"] EOA[\"EOA\"] ) );
+ public final ANTLRv3Parser.rewrite_alternative_return rewrite_alternative() throws RecognitionException {
+ ANTLRv3Parser.rewrite_alternative_return retval = new ANTLRv3Parser.rewrite_alternative_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ ANTLRv3Parser.rewrite_template_return rewrite_template151 = null;
+
+ ANTLRv3Parser.rewrite_tree_alternative_return rewrite_tree_alternative152 = null;
+
+
+
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:363:2: ( rewrite_template | rewrite_tree_alternative | -> ^( ALT[\"ALT\"] EPSILON[\"EPSILON\"] EOA[\"EOA\"] ) )
+ int alt73=3;
+ alt73 = dfa73.predict(input);
+ switch (alt73) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:363:4: rewrite_template
+ {
+ root_0 = (CommonTree)adaptor.nil();
+
+ pushFollow(FOLLOW_rewrite_template_in_rewrite_alternative2649);
+ rewrite_template151=rewrite_template();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) adaptor.addChild(root_0, rewrite_template151.getTree());
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:364:4: rewrite_tree_alternative
+ {
+ root_0 = (CommonTree)adaptor.nil();
+
+ pushFollow(FOLLOW_rewrite_tree_alternative_in_rewrite_alternative2654);
+ rewrite_tree_alternative152=rewrite_tree_alternative();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) adaptor.addChild(root_0, rewrite_tree_alternative152.getTree());
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3.g:365:29:
+ {
+
+ // AST REWRITE
+ // elements:
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 365:29: -> ^( ALT[\"ALT\"] EPSILON[\"EPSILON\"] EOA[\"EOA\"] )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:365:32: ^( ALT[\"ALT\"] EPSILON[\"EPSILON\"] EOA[\"EOA\"] )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ALT, "ALT"), root_1);
+
+ adaptor.addChild(root_1, (CommonTree)adaptor.create(EPSILON, "EPSILON"));
+ adaptor.addChild(root_1, (CommonTree)adaptor.create(EOA, "EOA"));
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+
+ }
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "rewrite_alternative"
+
+ public static class rewrite_tree_block_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "rewrite_tree_block"
+ // org/antlr/grammar/v3/ANTLRv3.g:368:1: rewrite_tree_block : lp= '(' rewrite_tree_alternative ')' -> ^( BLOCK[$lp,\"BLOCK\"] rewrite_tree_alternative EOB[$lp,\"EOB\"] ) ;
+ public final ANTLRv3Parser.rewrite_tree_block_return rewrite_tree_block() throws RecognitionException {
+ ANTLRv3Parser.rewrite_tree_block_return retval = new ANTLRv3Parser.rewrite_tree_block_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token lp=null;
+ Token char_literal154=null;
+ ANTLRv3Parser.rewrite_tree_alternative_return rewrite_tree_alternative153 = null;
+
+
+ CommonTree lp_tree=null;
+ CommonTree char_literal154_tree=null;
+ RewriteRuleTokenStream stream_83=new RewriteRuleTokenStream(adaptor,"token 83");
+ RewriteRuleTokenStream stream_81=new RewriteRuleTokenStream(adaptor,"token 81");
+ RewriteRuleSubtreeStream stream_rewrite_tree_alternative=new RewriteRuleSubtreeStream(adaptor,"rule rewrite_tree_alternative");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:369:5: (lp= '(' rewrite_tree_alternative ')' -> ^( BLOCK[$lp,\"BLOCK\"] rewrite_tree_alternative EOB[$lp,\"EOB\"] ) )
+ // org/antlr/grammar/v3/ANTLRv3.g:369:9: lp= '(' rewrite_tree_alternative ')'
+ {
+ lp=(Token)match(input,81,FOLLOW_81_in_rewrite_tree_block2696); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_81.add(lp);
+
+ pushFollow(FOLLOW_rewrite_tree_alternative_in_rewrite_tree_block2698);
+ rewrite_tree_alternative153=rewrite_tree_alternative();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_rewrite_tree_alternative.add(rewrite_tree_alternative153.getTree());
+ char_literal154=(Token)match(input,83,FOLLOW_83_in_rewrite_tree_block2700); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_83.add(char_literal154);
+
+
+
+ // AST REWRITE
+ // elements: rewrite_tree_alternative
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 370:6: -> ^( BLOCK[$lp,\"BLOCK\"] rewrite_tree_alternative EOB[$lp,\"EOB\"] )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:370:9: ^( BLOCK[$lp,\"BLOCK\"] rewrite_tree_alternative EOB[$lp,\"EOB\"] )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(BLOCK, lp, "BLOCK"), root_1);
+
+ adaptor.addChild(root_1, stream_rewrite_tree_alternative.nextTree());
+ adaptor.addChild(root_1, (CommonTree)adaptor.create(EOB, lp, "EOB"));
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "rewrite_tree_block"
+
+ public static class rewrite_tree_alternative_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "rewrite_tree_alternative"
+ // org/antlr/grammar/v3/ANTLRv3.g:373:1: rewrite_tree_alternative : ( rewrite_tree_element )+ -> ^( ALT[\"ALT\"] ( rewrite_tree_element )+ EOA[\"EOA\"] ) ;
+ public final ANTLRv3Parser.rewrite_tree_alternative_return rewrite_tree_alternative() throws RecognitionException {
+ ANTLRv3Parser.rewrite_tree_alternative_return retval = new ANTLRv3Parser.rewrite_tree_alternative_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ ANTLRv3Parser.rewrite_tree_element_return rewrite_tree_element155 = null;
+
+
+ RewriteRuleSubtreeStream stream_rewrite_tree_element=new RewriteRuleSubtreeStream(adaptor,"rule rewrite_tree_element");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:374:5: ( ( rewrite_tree_element )+ -> ^( ALT[\"ALT\"] ( rewrite_tree_element )+ EOA[\"EOA\"] ) )
+ // org/antlr/grammar/v3/ANTLRv3.g:374:7: ( rewrite_tree_element )+
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:374:7: ( rewrite_tree_element )+
+ int cnt74=0;
+ loop74:
+ do {
+ int alt74=2;
+ int LA74_0 = input.LA(1);
+
+ if ( (LA74_0==TREE_BEGIN||(LA74_0>=TOKEN_REF && LA74_0<=ACTION)||LA74_0==RULE_REF||LA74_0==81||LA74_0==93) ) {
+ alt74=1;
+ }
+
+
+ switch (alt74) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:374:7: rewrite_tree_element
+ {
+ pushFollow(FOLLOW_rewrite_tree_element_in_rewrite_tree_alternative2734);
+ rewrite_tree_element155=rewrite_tree_element();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_rewrite_tree_element.add(rewrite_tree_element155.getTree());
+
+ }
+ break;
+
+ default :
+ if ( cnt74 >= 1 ) break loop74;
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ EarlyExitException eee =
+ new EarlyExitException(74, input);
+ throw eee;
+ }
+ cnt74++;
+ } while (true);
+
+
+
+ // AST REWRITE
+ // elements: rewrite_tree_element
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 374:29: -> ^( ALT[\"ALT\"] ( rewrite_tree_element )+ EOA[\"EOA\"] )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:374:32: ^( ALT[\"ALT\"] ( rewrite_tree_element )+ EOA[\"EOA\"] )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ALT, "ALT"), root_1);
+
+ if ( !(stream_rewrite_tree_element.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_rewrite_tree_element.hasNext() ) {
+ adaptor.addChild(root_1, stream_rewrite_tree_element.nextTree());
+
+ }
+ stream_rewrite_tree_element.reset();
+ adaptor.addChild(root_1, (CommonTree)adaptor.create(EOA, "EOA"));
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "rewrite_tree_alternative"
+
+ public static class rewrite_tree_element_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "rewrite_tree_element"
+ // org/antlr/grammar/v3/ANTLRv3.g:377:1: rewrite_tree_element : ( rewrite_tree_atom | rewrite_tree_atom ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] rewrite_tree_atom EOA[\"EOA\"] ) EOB[\"EOB\"] ) ) | rewrite_tree ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] rewrite_tree EOA[\"EOA\"] ) EOB[\"EOB\"] ) ) | -> rewrite_tree ) | rewrite_tree_ebnf );
+ public final ANTLRv3Parser.rewrite_tree_element_return rewrite_tree_element() throws RecognitionException {
+ ANTLRv3Parser.rewrite_tree_element_return retval = new ANTLRv3Parser.rewrite_tree_element_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ ANTLRv3Parser.rewrite_tree_atom_return rewrite_tree_atom156 = null;
+
+ ANTLRv3Parser.rewrite_tree_atom_return rewrite_tree_atom157 = null;
+
+ ANTLRv3Parser.ebnfSuffix_return ebnfSuffix158 = null;
+
+ ANTLRv3Parser.rewrite_tree_return rewrite_tree159 = null;
+
+ ANTLRv3Parser.ebnfSuffix_return ebnfSuffix160 = null;
+
+ ANTLRv3Parser.rewrite_tree_ebnf_return rewrite_tree_ebnf161 = null;
+
+
+ RewriteRuleSubtreeStream stream_rewrite_tree=new RewriteRuleSubtreeStream(adaptor,"rule rewrite_tree");
+ RewriteRuleSubtreeStream stream_ebnfSuffix=new RewriteRuleSubtreeStream(adaptor,"rule ebnfSuffix");
+ RewriteRuleSubtreeStream stream_rewrite_tree_atom=new RewriteRuleSubtreeStream(adaptor,"rule rewrite_tree_atom");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:378:2: ( rewrite_tree_atom | rewrite_tree_atom ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] rewrite_tree_atom EOA[\"EOA\"] ) EOB[\"EOB\"] ) ) | rewrite_tree ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] rewrite_tree EOA[\"EOA\"] ) EOB[\"EOB\"] ) ) | -> rewrite_tree ) | rewrite_tree_ebnf )
+ int alt76=4;
+ alt76 = dfa76.predict(input);
+ switch (alt76) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:378:4: rewrite_tree_atom
+ {
+ root_0 = (CommonTree)adaptor.nil();
+
+ pushFollow(FOLLOW_rewrite_tree_atom_in_rewrite_tree_element2762);
+ rewrite_tree_atom156=rewrite_tree_atom();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) adaptor.addChild(root_0, rewrite_tree_atom156.getTree());
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:379:4: rewrite_tree_atom ebnfSuffix
+ {
+ pushFollow(FOLLOW_rewrite_tree_atom_in_rewrite_tree_element2767);
+ rewrite_tree_atom157=rewrite_tree_atom();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_rewrite_tree_atom.add(rewrite_tree_atom157.getTree());
+ pushFollow(FOLLOW_ebnfSuffix_in_rewrite_tree_element2769);
+ ebnfSuffix158=ebnfSuffix();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ebnfSuffix.add(ebnfSuffix158.getTree());
+
+
+ // AST REWRITE
+ // elements: rewrite_tree_atom, ebnfSuffix
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 380:3: -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] rewrite_tree_atom EOA[\"EOA\"] ) EOB[\"EOB\"] ) )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:380:6: ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] rewrite_tree_atom EOA[\"EOA\"] ) EOB[\"EOB\"] ) )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_ebnfSuffix.nextNode(), root_1);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:380:20: ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] rewrite_tree_atom EOA[\"EOA\"] ) EOB[\"EOB\"] )
+ {
+ CommonTree root_2 = (CommonTree)adaptor.nil();
+ root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(BLOCK, "BLOCK"), root_2);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:380:37: ^( ALT[\"ALT\"] rewrite_tree_atom EOA[\"EOA\"] )
+ {
+ CommonTree root_3 = (CommonTree)adaptor.nil();
+ root_3 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ALT, "ALT"), root_3);
+
+ adaptor.addChild(root_3, stream_rewrite_tree_atom.nextTree());
+ adaptor.addChild(root_3, (CommonTree)adaptor.create(EOA, "EOA"));
+
+ adaptor.addChild(root_2, root_3);
+ }
+ adaptor.addChild(root_2, (CommonTree)adaptor.create(EOB, "EOB"));
+
+ adaptor.addChild(root_1, root_2);
+ }
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3.g:381:6: rewrite_tree ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] rewrite_tree EOA[\"EOA\"] ) EOB[\"EOB\"] ) ) | -> rewrite_tree )
+ {
+ pushFollow(FOLLOW_rewrite_tree_in_rewrite_tree_element2803);
+ rewrite_tree159=rewrite_tree();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_rewrite_tree.add(rewrite_tree159.getTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:382:3: ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] rewrite_tree EOA[\"EOA\"] ) EOB[\"EOB\"] ) ) | -> rewrite_tree )
+ int alt75=2;
+ int LA75_0 = input.LA(1);
+
+ if ( (LA75_0==74||(LA75_0>=91 && LA75_0<=92)) ) {
+ alt75=1;
+ }
+ else if ( (LA75_0==EOF||LA75_0==TREE_BEGIN||LA75_0==REWRITE||(LA75_0>=TOKEN_REF && LA75_0<=ACTION)||LA75_0==RULE_REF||LA75_0==71||(LA75_0>=81 && LA75_0<=83)||LA75_0==93) ) {
+ alt75=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 75, 0, input);
+
+ throw nvae;
+ }
+ switch (alt75) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:382:5: ebnfSuffix
+ {
+ pushFollow(FOLLOW_ebnfSuffix_in_rewrite_tree_element2809);
+ ebnfSuffix160=ebnfSuffix();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ebnfSuffix.add(ebnfSuffix160.getTree());
+
+
+ // AST REWRITE
+ // elements: rewrite_tree, ebnfSuffix
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 383:4: -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] rewrite_tree EOA[\"EOA\"] ) EOB[\"EOB\"] ) )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:383:7: ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] rewrite_tree EOA[\"EOA\"] ) EOB[\"EOB\"] ) )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_ebnfSuffix.nextNode(), root_1);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:383:20: ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] rewrite_tree EOA[\"EOA\"] ) EOB[\"EOB\"] )
+ {
+ CommonTree root_2 = (CommonTree)adaptor.nil();
+ root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(BLOCK, "BLOCK"), root_2);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:383:37: ^( ALT[\"ALT\"] rewrite_tree EOA[\"EOA\"] )
+ {
+ CommonTree root_3 = (CommonTree)adaptor.nil();
+ root_3 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ALT, "ALT"), root_3);
+
+ adaptor.addChild(root_3, stream_rewrite_tree.nextTree());
+ adaptor.addChild(root_3, (CommonTree)adaptor.create(EOA, "EOA"));
+
+ adaptor.addChild(root_2, root_3);
+ }
+ adaptor.addChild(root_2, (CommonTree)adaptor.create(EOB, "EOB"));
+
+ adaptor.addChild(root_1, root_2);
+ }
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:384:5:
+ {
+
+ // AST REWRITE
+ // elements: rewrite_tree
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 384:5: -> rewrite_tree
+ {
+ adaptor.addChild(root_0, stream_rewrite_tree.nextTree());
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+ case 4 :
+ // org/antlr/grammar/v3/ANTLRv3.g:386:6: rewrite_tree_ebnf
+ {
+ root_0 = (CommonTree)adaptor.nil();
+
+ pushFollow(FOLLOW_rewrite_tree_ebnf_in_rewrite_tree_element2855);
+ rewrite_tree_ebnf161=rewrite_tree_ebnf();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) adaptor.addChild(root_0, rewrite_tree_ebnf161.getTree());
+
+ }
+ break;
+
+ }
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "rewrite_tree_element"
+
+ public static class rewrite_tree_atom_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "rewrite_tree_atom"
+ // org/antlr/grammar/v3/ANTLRv3.g:389:1: rewrite_tree_atom : ( CHAR_LITERAL | TOKEN_REF ( ARG_ACTION )? -> ^( TOKEN_REF ( ARG_ACTION )? ) | RULE_REF | STRING_LITERAL | d= '$' id -> LABEL[$d,$id.text] | ACTION );
+ public final ANTLRv3Parser.rewrite_tree_atom_return rewrite_tree_atom() throws RecognitionException {
+ ANTLRv3Parser.rewrite_tree_atom_return retval = new ANTLRv3Parser.rewrite_tree_atom_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token d=null;
+ Token CHAR_LITERAL162=null;
+ Token TOKEN_REF163=null;
+ Token ARG_ACTION164=null;
+ Token RULE_REF165=null;
+ Token STRING_LITERAL166=null;
+ Token ACTION168=null;
+ ANTLRv3Parser.id_return id167 = null;
+
+
+ CommonTree d_tree=null;
+ CommonTree CHAR_LITERAL162_tree=null;
+ CommonTree TOKEN_REF163_tree=null;
+ CommonTree ARG_ACTION164_tree=null;
+ CommonTree RULE_REF165_tree=null;
+ CommonTree STRING_LITERAL166_tree=null;
+ CommonTree ACTION168_tree=null;
+ RewriteRuleTokenStream stream_93=new RewriteRuleTokenStream(adaptor,"token 93");
+ RewriteRuleTokenStream stream_TOKEN_REF=new RewriteRuleTokenStream(adaptor,"token TOKEN_REF");
+ RewriteRuleTokenStream stream_ARG_ACTION=new RewriteRuleTokenStream(adaptor,"token ARG_ACTION");
+ RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:390:5: ( CHAR_LITERAL | TOKEN_REF ( ARG_ACTION )? -> ^( TOKEN_REF ( ARG_ACTION )? ) | RULE_REF | STRING_LITERAL | d= '$' id -> LABEL[$d,$id.text] | ACTION )
+ int alt78=6;
+ switch ( input.LA(1) ) {
+ case CHAR_LITERAL:
+ {
+ alt78=1;
+ }
+ break;
+ case TOKEN_REF:
+ {
+ alt78=2;
+ }
+ break;
+ case RULE_REF:
+ {
+ alt78=3;
+ }
+ break;
+ case STRING_LITERAL:
+ {
+ alt78=4;
+ }
+ break;
+ case 93:
+ {
+ alt78=5;
+ }
+ break;
+ case ACTION:
+ {
+ alt78=6;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 78, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt78) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:390:9: CHAR_LITERAL
+ {
+ root_0 = (CommonTree)adaptor.nil();
+
+ CHAR_LITERAL162=(Token)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_rewrite_tree_atom2871); if (state.failed) return retval;
+ if ( state.backtracking==0 ) {
+ CHAR_LITERAL162_tree = (CommonTree)adaptor.create(CHAR_LITERAL162);
+ adaptor.addChild(root_0, CHAR_LITERAL162_tree);
+ }
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:391:6: TOKEN_REF ( ARG_ACTION )?
+ {
+ TOKEN_REF163=(Token)match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_rewrite_tree_atom2878); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_TOKEN_REF.add(TOKEN_REF163);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:391:16: ( ARG_ACTION )?
+ int alt77=2;
+ int LA77_0 = input.LA(1);
+
+ if ( (LA77_0==ARG_ACTION) ) {
+ alt77=1;
+ }
+ switch (alt77) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:391:16: ARG_ACTION
+ {
+ ARG_ACTION164=(Token)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_rewrite_tree_atom2880); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ARG_ACTION.add(ARG_ACTION164);
+
+
+ }
+ break;
+
+ }
+
+
+
+ // AST REWRITE
+ // elements: TOKEN_REF, ARG_ACTION
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 391:28: -> ^( TOKEN_REF ( ARG_ACTION )? )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:391:31: ^( TOKEN_REF ( ARG_ACTION )? )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_TOKEN_REF.nextNode(), root_1);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:391:43: ( ARG_ACTION )?
+ if ( stream_ARG_ACTION.hasNext() ) {
+ adaptor.addChild(root_1, stream_ARG_ACTION.nextNode());
+
+ }
+ stream_ARG_ACTION.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3.g:392:9: RULE_REF
+ {
+ root_0 = (CommonTree)adaptor.nil();
+
+ RULE_REF165=(Token)match(input,RULE_REF,FOLLOW_RULE_REF_in_rewrite_tree_atom2901); if (state.failed) return retval;
+ if ( state.backtracking==0 ) {
+ RULE_REF165_tree = (CommonTree)adaptor.create(RULE_REF165);
+ adaptor.addChild(root_0, RULE_REF165_tree);
+ }
+
+ }
+ break;
+ case 4 :
+ // org/antlr/grammar/v3/ANTLRv3.g:393:6: STRING_LITERAL
+ {
+ root_0 = (CommonTree)adaptor.nil();
+
+ STRING_LITERAL166=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_rewrite_tree_atom2908); if (state.failed) return retval;
+ if ( state.backtracking==0 ) {
+ STRING_LITERAL166_tree = (CommonTree)adaptor.create(STRING_LITERAL166);
+ adaptor.addChild(root_0, STRING_LITERAL166_tree);
+ }
+
+ }
+ break;
+ case 5 :
+ // org/antlr/grammar/v3/ANTLRv3.g:394:6: d= '$' id
+ {
+ d=(Token)match(input,93,FOLLOW_93_in_rewrite_tree_atom2917); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_93.add(d);
+
+ pushFollow(FOLLOW_id_in_rewrite_tree_atom2919);
+ id167=id();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_id.add(id167.getTree());
+
+
+ // AST REWRITE
+ // elements:
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 394:15: -> LABEL[$d,$id.text]
+ {
+ adaptor.addChild(root_0, (CommonTree)adaptor.create(LABEL, d, (id167!=null?input.toString(id167.start,id167.stop):null)));
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 6 :
+ // org/antlr/grammar/v3/ANTLRv3.g:395:4: ACTION
+ {
+ root_0 = (CommonTree)adaptor.nil();
+
+ ACTION168=(Token)match(input,ACTION,FOLLOW_ACTION_in_rewrite_tree_atom2930); if (state.failed) return retval;
+ if ( state.backtracking==0 ) {
+ ACTION168_tree = (CommonTree)adaptor.create(ACTION168);
+ adaptor.addChild(root_0, ACTION168_tree);
+ }
+
+ }
+ break;
+
+ }
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "rewrite_tree_atom"
+
+ public static class rewrite_tree_ebnf_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "rewrite_tree_ebnf"
+ // org/antlr/grammar/v3/ANTLRv3.g:398:1: rewrite_tree_ebnf : rewrite_tree_block ebnfSuffix -> ^( ebnfSuffix rewrite_tree_block ) ;
+ public final ANTLRv3Parser.rewrite_tree_ebnf_return rewrite_tree_ebnf() throws RecognitionException {
+ ANTLRv3Parser.rewrite_tree_ebnf_return retval = new ANTLRv3Parser.rewrite_tree_ebnf_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ ANTLRv3Parser.rewrite_tree_block_return rewrite_tree_block169 = null;
+
+ ANTLRv3Parser.ebnfSuffix_return ebnfSuffix170 = null;
+
+
+ RewriteRuleSubtreeStream stream_ebnfSuffix=new RewriteRuleSubtreeStream(adaptor,"rule ebnfSuffix");
+ RewriteRuleSubtreeStream stream_rewrite_tree_block=new RewriteRuleSubtreeStream(adaptor,"rule rewrite_tree_block");
+
+ Token firstToken = input.LT(1);
+
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:406:2: ( rewrite_tree_block ebnfSuffix -> ^( ebnfSuffix rewrite_tree_block ) )
+ // org/antlr/grammar/v3/ANTLRv3.g:406:4: rewrite_tree_block ebnfSuffix
+ {
+ pushFollow(FOLLOW_rewrite_tree_block_in_rewrite_tree_ebnf2951);
+ rewrite_tree_block169=rewrite_tree_block();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_rewrite_tree_block.add(rewrite_tree_block169.getTree());
+ pushFollow(FOLLOW_ebnfSuffix_in_rewrite_tree_ebnf2953);
+ ebnfSuffix170=ebnfSuffix();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ebnfSuffix.add(ebnfSuffix170.getTree());
+
+
+ // AST REWRITE
+ // elements: ebnfSuffix, rewrite_tree_block
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 406:34: -> ^( ebnfSuffix rewrite_tree_block )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:406:37: ^( ebnfSuffix rewrite_tree_block )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot(stream_ebnfSuffix.nextNode(), root_1);
+
+ adaptor.addChild(root_1, stream_rewrite_tree_block.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ if ( state.backtracking==0 ) {
+
+ ((CommonTree)retval.tree).getToken().setLine(firstToken.getLine());
+ ((CommonTree)retval.tree).getToken().setCharPositionInLine(firstToken.getCharPositionInLine());
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "rewrite_tree_ebnf"
+
+ public static class rewrite_tree_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "rewrite_tree"
+ // org/antlr/grammar/v3/ANTLRv3.g:409:1: rewrite_tree : '^(' rewrite_tree_atom ( rewrite_tree_element )* ')' -> ^( TREE_BEGIN rewrite_tree_atom ( rewrite_tree_element )* ) ;
+ public final ANTLRv3Parser.rewrite_tree_return rewrite_tree() throws RecognitionException {
+ ANTLRv3Parser.rewrite_tree_return retval = new ANTLRv3Parser.rewrite_tree_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token string_literal171=null;
+ Token char_literal174=null;
+ ANTLRv3Parser.rewrite_tree_atom_return rewrite_tree_atom172 = null;
+
+ ANTLRv3Parser.rewrite_tree_element_return rewrite_tree_element173 = null;
+
+
+ CommonTree string_literal171_tree=null;
+ CommonTree char_literal174_tree=null;
+ RewriteRuleTokenStream stream_83=new RewriteRuleTokenStream(adaptor,"token 83");
+ RewriteRuleTokenStream stream_TREE_BEGIN=new RewriteRuleTokenStream(adaptor,"token TREE_BEGIN");
+ RewriteRuleSubtreeStream stream_rewrite_tree_element=new RewriteRuleSubtreeStream(adaptor,"rule rewrite_tree_element");
+ RewriteRuleSubtreeStream stream_rewrite_tree_atom=new RewriteRuleSubtreeStream(adaptor,"rule rewrite_tree_atom");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:410:2: ( '^(' rewrite_tree_atom ( rewrite_tree_element )* ')' -> ^( TREE_BEGIN rewrite_tree_atom ( rewrite_tree_element )* ) )
+ // org/antlr/grammar/v3/ANTLRv3.g:410:4: '^(' rewrite_tree_atom ( rewrite_tree_element )* ')'
+ {
+ string_literal171=(Token)match(input,TREE_BEGIN,FOLLOW_TREE_BEGIN_in_rewrite_tree2973); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_TREE_BEGIN.add(string_literal171);
+
+ pushFollow(FOLLOW_rewrite_tree_atom_in_rewrite_tree2975);
+ rewrite_tree_atom172=rewrite_tree_atom();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_rewrite_tree_atom.add(rewrite_tree_atom172.getTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:410:27: ( rewrite_tree_element )*
+ loop79:
+ do {
+ int alt79=2;
+ int LA79_0 = input.LA(1);
+
+ if ( (LA79_0==TREE_BEGIN||(LA79_0>=TOKEN_REF && LA79_0<=ACTION)||LA79_0==RULE_REF||LA79_0==81||LA79_0==93) ) {
+ alt79=1;
+ }
+
+
+ switch (alt79) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:410:27: rewrite_tree_element
+ {
+ pushFollow(FOLLOW_rewrite_tree_element_in_rewrite_tree2977);
+ rewrite_tree_element173=rewrite_tree_element();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_rewrite_tree_element.add(rewrite_tree_element173.getTree());
+
+ }
+ break;
+
+ default :
+ break loop79;
+ }
+ } while (true);
+
+ char_literal174=(Token)match(input,83,FOLLOW_83_in_rewrite_tree2980); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_83.add(char_literal174);
+
+
+
+ // AST REWRITE
+ // elements: rewrite_tree_atom, rewrite_tree_element
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 411:3: -> ^( TREE_BEGIN rewrite_tree_atom ( rewrite_tree_element )* )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:411:6: ^( TREE_BEGIN rewrite_tree_atom ( rewrite_tree_element )* )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TREE_BEGIN, "TREE_BEGIN"), root_1);
+
+ adaptor.addChild(root_1, stream_rewrite_tree_atom.nextTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:411:37: ( rewrite_tree_element )*
+ while ( stream_rewrite_tree_element.hasNext() ) {
+ adaptor.addChild(root_1, stream_rewrite_tree_element.nextTree());
+
+ }
+ stream_rewrite_tree_element.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "rewrite_tree"
+
+ public static class rewrite_template_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "rewrite_template"
+ // org/antlr/grammar/v3/ANTLRv3.g:414:1: rewrite_template : ( id lp= '(' rewrite_template_args ')' (str= DOUBLE_QUOTE_STRING_LITERAL | str= DOUBLE_ANGLE_STRING_LITERAL ) -> ^( TEMPLATE[$lp,\"TEMPLATE\"] id rewrite_template_args $str) | rewrite_template_ref | rewrite_indirect_template_head | ACTION );
+ public final ANTLRv3Parser.rewrite_template_return rewrite_template() throws RecognitionException {
+ ANTLRv3Parser.rewrite_template_return retval = new ANTLRv3Parser.rewrite_template_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token lp=null;
+ Token str=null;
+ Token char_literal177=null;
+ Token ACTION180=null;
+ ANTLRv3Parser.id_return id175 = null;
+
+ ANTLRv3Parser.rewrite_template_args_return rewrite_template_args176 = null;
+
+ ANTLRv3Parser.rewrite_template_ref_return rewrite_template_ref178 = null;
+
+ ANTLRv3Parser.rewrite_indirect_template_head_return rewrite_indirect_template_head179 = null;
+
+
+ CommonTree lp_tree=null;
+ CommonTree str_tree=null;
+ CommonTree char_literal177_tree=null;
+ CommonTree ACTION180_tree=null;
+ RewriteRuleTokenStream stream_DOUBLE_QUOTE_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token DOUBLE_QUOTE_STRING_LITERAL");
+ RewriteRuleTokenStream stream_83=new RewriteRuleTokenStream(adaptor,"token 83");
+ RewriteRuleTokenStream stream_DOUBLE_ANGLE_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token DOUBLE_ANGLE_STRING_LITERAL");
+ RewriteRuleTokenStream stream_81=new RewriteRuleTokenStream(adaptor,"token 81");
+ RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
+ RewriteRuleSubtreeStream stream_rewrite_template_args=new RewriteRuleSubtreeStream(adaptor,"rule rewrite_template_args");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:426:2: ( id lp= '(' rewrite_template_args ')' (str= DOUBLE_QUOTE_STRING_LITERAL | str= DOUBLE_ANGLE_STRING_LITERAL ) -> ^( TEMPLATE[$lp,\"TEMPLATE\"] id rewrite_template_args $str) | rewrite_template_ref | rewrite_indirect_template_head | ACTION )
+ int alt81=4;
+ alt81 = dfa81.predict(input);
+ switch (alt81) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:427:3: id lp= '(' rewrite_template_args ')' (str= DOUBLE_QUOTE_STRING_LITERAL | str= DOUBLE_ANGLE_STRING_LITERAL )
+ {
+ pushFollow(FOLLOW_id_in_rewrite_template3012);
+ id175=id();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_id.add(id175.getTree());
+ lp=(Token)match(input,81,FOLLOW_81_in_rewrite_template3016); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_81.add(lp);
+
+ pushFollow(FOLLOW_rewrite_template_args_in_rewrite_template3018);
+ rewrite_template_args176=rewrite_template_args();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_rewrite_template_args.add(rewrite_template_args176.getTree());
+ char_literal177=(Token)match(input,83,FOLLOW_83_in_rewrite_template3020); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_83.add(char_literal177);
+
+ // org/antlr/grammar/v3/ANTLRv3.g:428:3: (str= DOUBLE_QUOTE_STRING_LITERAL | str= DOUBLE_ANGLE_STRING_LITERAL )
+ int alt80=2;
+ int LA80_0 = input.LA(1);
+
+ if ( (LA80_0==DOUBLE_QUOTE_STRING_LITERAL) ) {
+ alt80=1;
+ }
+ else if ( (LA80_0==DOUBLE_ANGLE_STRING_LITERAL) ) {
+ alt80=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 80, 0, input);
+
+ throw nvae;
+ }
+ switch (alt80) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:428:5: str= DOUBLE_QUOTE_STRING_LITERAL
+ {
+ str=(Token)match(input,DOUBLE_QUOTE_STRING_LITERAL,FOLLOW_DOUBLE_QUOTE_STRING_LITERAL_in_rewrite_template3028); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_DOUBLE_QUOTE_STRING_LITERAL.add(str);
+
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:428:39: str= DOUBLE_ANGLE_STRING_LITERAL
+ {
+ str=(Token)match(input,DOUBLE_ANGLE_STRING_LITERAL,FOLLOW_DOUBLE_ANGLE_STRING_LITERAL_in_rewrite_template3034); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_DOUBLE_ANGLE_STRING_LITERAL.add(str);
+
+
+ }
+ break;
+
+ }
+
+
+
+ // AST REWRITE
+ // elements: rewrite_template_args, id, str
+ // token labels: str
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleTokenStream stream_str=new RewriteRuleTokenStream(adaptor,"token str",str);
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 429:3: -> ^( TEMPLATE[$lp,\"TEMPLATE\"] id rewrite_template_args $str)
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:429:6: ^( TEMPLATE[$lp,\"TEMPLATE\"] id rewrite_template_args $str)
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TEMPLATE, lp, "TEMPLATE"), root_1);
+
+ adaptor.addChild(root_1, stream_id.nextTree());
+ adaptor.addChild(root_1, stream_rewrite_template_args.nextTree());
+ adaptor.addChild(root_1, stream_str.nextNode());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:432:3: rewrite_template_ref
+ {
+ root_0 = (CommonTree)adaptor.nil();
+
+ pushFollow(FOLLOW_rewrite_template_ref_in_rewrite_template3061);
+ rewrite_template_ref178=rewrite_template_ref();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) adaptor.addChild(root_0, rewrite_template_ref178.getTree());
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3.g:435:3: rewrite_indirect_template_head
+ {
+ root_0 = (CommonTree)adaptor.nil();
+
+ pushFollow(FOLLOW_rewrite_indirect_template_head_in_rewrite_template3070);
+ rewrite_indirect_template_head179=rewrite_indirect_template_head();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) adaptor.addChild(root_0, rewrite_indirect_template_head179.getTree());
+
+ }
+ break;
+ case 4 :
+ // org/antlr/grammar/v3/ANTLRv3.g:438:3: ACTION
+ {
+ root_0 = (CommonTree)adaptor.nil();
+
+ ACTION180=(Token)match(input,ACTION,FOLLOW_ACTION_in_rewrite_template3079); if (state.failed) return retval;
+ if ( state.backtracking==0 ) {
+ ACTION180_tree = (CommonTree)adaptor.create(ACTION180);
+ adaptor.addChild(root_0, ACTION180_tree);
+ }
+
+ }
+ break;
+
+ }
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "rewrite_template"
+
+ public static class rewrite_template_ref_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "rewrite_template_ref"
+ // org/antlr/grammar/v3/ANTLRv3.g:441:1: rewrite_template_ref : id lp= '(' rewrite_template_args ')' -> ^( TEMPLATE[$lp,\"TEMPLATE\"] id rewrite_template_args ) ;
+ public final ANTLRv3Parser.rewrite_template_ref_return rewrite_template_ref() throws RecognitionException {
+ ANTLRv3Parser.rewrite_template_ref_return retval = new ANTLRv3Parser.rewrite_template_ref_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token lp=null;
+ Token char_literal183=null;
+ ANTLRv3Parser.id_return id181 = null;
+
+ ANTLRv3Parser.rewrite_template_args_return rewrite_template_args182 = null;
+
+
+ CommonTree lp_tree=null;
+ CommonTree char_literal183_tree=null;
+ RewriteRuleTokenStream stream_83=new RewriteRuleTokenStream(adaptor,"token 83");
+ RewriteRuleTokenStream stream_81=new RewriteRuleTokenStream(adaptor,"token 81");
+ RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
+ RewriteRuleSubtreeStream stream_rewrite_template_args=new RewriteRuleSubtreeStream(adaptor,"rule rewrite_template_args");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:443:2: ( id lp= '(' rewrite_template_args ')' -> ^( TEMPLATE[$lp,\"TEMPLATE\"] id rewrite_template_args ) )
+ // org/antlr/grammar/v3/ANTLRv3.g:443:4: id lp= '(' rewrite_template_args ')'
+ {
+ pushFollow(FOLLOW_id_in_rewrite_template_ref3092);
+ id181=id();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_id.add(id181.getTree());
+ lp=(Token)match(input,81,FOLLOW_81_in_rewrite_template_ref3096); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_81.add(lp);
+
+ pushFollow(FOLLOW_rewrite_template_args_in_rewrite_template_ref3098);
+ rewrite_template_args182=rewrite_template_args();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_rewrite_template_args.add(rewrite_template_args182.getTree());
+ char_literal183=(Token)match(input,83,FOLLOW_83_in_rewrite_template_ref3100); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_83.add(char_literal183);
+
+
+
+ // AST REWRITE
+ // elements: rewrite_template_args, id
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 444:3: -> ^( TEMPLATE[$lp,\"TEMPLATE\"] id rewrite_template_args )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:444:6: ^( TEMPLATE[$lp,\"TEMPLATE\"] id rewrite_template_args )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TEMPLATE, lp, "TEMPLATE"), root_1);
+
+ adaptor.addChild(root_1, stream_id.nextTree());
+ adaptor.addChild(root_1, stream_rewrite_template_args.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "rewrite_template_ref"
+
+ public static class rewrite_indirect_template_head_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "rewrite_indirect_template_head"
+ // org/antlr/grammar/v3/ANTLRv3.g:447:1: rewrite_indirect_template_head : lp= '(' ACTION ')' '(' rewrite_template_args ')' -> ^( TEMPLATE[$lp,\"TEMPLATE\"] ACTION rewrite_template_args ) ;
+ public final ANTLRv3Parser.rewrite_indirect_template_head_return rewrite_indirect_template_head() throws RecognitionException {
+ ANTLRv3Parser.rewrite_indirect_template_head_return retval = new ANTLRv3Parser.rewrite_indirect_template_head_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token lp=null;
+ Token ACTION184=null;
+ Token char_literal185=null;
+ Token char_literal186=null;
+ Token char_literal188=null;
+ ANTLRv3Parser.rewrite_template_args_return rewrite_template_args187 = null;
+
+
+ CommonTree lp_tree=null;
+ CommonTree ACTION184_tree=null;
+ CommonTree char_literal185_tree=null;
+ CommonTree char_literal186_tree=null;
+ CommonTree char_literal188_tree=null;
+ RewriteRuleTokenStream stream_83=new RewriteRuleTokenStream(adaptor,"token 83");
+ RewriteRuleTokenStream stream_81=new RewriteRuleTokenStream(adaptor,"token 81");
+ RewriteRuleTokenStream stream_ACTION=new RewriteRuleTokenStream(adaptor,"token ACTION");
+ RewriteRuleSubtreeStream stream_rewrite_template_args=new RewriteRuleSubtreeStream(adaptor,"rule rewrite_template_args");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:449:2: (lp= '(' ACTION ')' '(' rewrite_template_args ')' -> ^( TEMPLATE[$lp,\"TEMPLATE\"] ACTION rewrite_template_args ) )
+ // org/antlr/grammar/v3/ANTLRv3.g:449:4: lp= '(' ACTION ')' '(' rewrite_template_args ')'
+ {
+ lp=(Token)match(input,81,FOLLOW_81_in_rewrite_indirect_template_head3128); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_81.add(lp);
+
+ ACTION184=(Token)match(input,ACTION,FOLLOW_ACTION_in_rewrite_indirect_template_head3130); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ACTION.add(ACTION184);
+
+ char_literal185=(Token)match(input,83,FOLLOW_83_in_rewrite_indirect_template_head3132); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_83.add(char_literal185);
+
+ char_literal186=(Token)match(input,81,FOLLOW_81_in_rewrite_indirect_template_head3134); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_81.add(char_literal186);
+
+ pushFollow(FOLLOW_rewrite_template_args_in_rewrite_indirect_template_head3136);
+ rewrite_template_args187=rewrite_template_args();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_rewrite_template_args.add(rewrite_template_args187.getTree());
+ char_literal188=(Token)match(input,83,FOLLOW_83_in_rewrite_indirect_template_head3138); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_83.add(char_literal188);
+
+
+
+ // AST REWRITE
+ // elements: ACTION, rewrite_template_args
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 450:3: -> ^( TEMPLATE[$lp,\"TEMPLATE\"] ACTION rewrite_template_args )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:450:6: ^( TEMPLATE[$lp,\"TEMPLATE\"] ACTION rewrite_template_args )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TEMPLATE, lp, "TEMPLATE"), root_1);
+
+ adaptor.addChild(root_1, stream_ACTION.nextNode());
+ adaptor.addChild(root_1, stream_rewrite_template_args.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "rewrite_indirect_template_head"
+
+ public static class rewrite_template_args_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "rewrite_template_args"
+ // org/antlr/grammar/v3/ANTLRv3.g:453:1: rewrite_template_args : ( rewrite_template_arg ( ',' rewrite_template_arg )* -> ^( ARGLIST ( rewrite_template_arg )+ ) | -> ARGLIST );
+ public final ANTLRv3Parser.rewrite_template_args_return rewrite_template_args() throws RecognitionException {
+ ANTLRv3Parser.rewrite_template_args_return retval = new ANTLRv3Parser.rewrite_template_args_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token char_literal190=null;
+ ANTLRv3Parser.rewrite_template_arg_return rewrite_template_arg189 = null;
+
+ ANTLRv3Parser.rewrite_template_arg_return rewrite_template_arg191 = null;
+
+
+ CommonTree char_literal190_tree=null;
+ RewriteRuleTokenStream stream_80=new RewriteRuleTokenStream(adaptor,"token 80");
+ RewriteRuleSubtreeStream stream_rewrite_template_arg=new RewriteRuleSubtreeStream(adaptor,"rule rewrite_template_arg");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:454:2: ( rewrite_template_arg ( ',' rewrite_template_arg )* -> ^( ARGLIST ( rewrite_template_arg )+ ) | -> ARGLIST )
+ int alt83=2;
+ int LA83_0 = input.LA(1);
+
+ if ( (LA83_0==TOKEN_REF||LA83_0==RULE_REF) ) {
+ alt83=1;
+ }
+ else if ( (LA83_0==83) ) {
+ alt83=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 83, 0, input);
+
+ throw nvae;
+ }
+ switch (alt83) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:454:4: rewrite_template_arg ( ',' rewrite_template_arg )*
+ {
+ pushFollow(FOLLOW_rewrite_template_arg_in_rewrite_template_args3162);
+ rewrite_template_arg189=rewrite_template_arg();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_rewrite_template_arg.add(rewrite_template_arg189.getTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:454:25: ( ',' rewrite_template_arg )*
+ loop82:
+ do {
+ int alt82=2;
+ int LA82_0 = input.LA(1);
+
+ if ( (LA82_0==80) ) {
+ alt82=1;
+ }
+
+
+ switch (alt82) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:454:26: ',' rewrite_template_arg
+ {
+ char_literal190=(Token)match(input,80,FOLLOW_80_in_rewrite_template_args3165); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_80.add(char_literal190);
+
+ pushFollow(FOLLOW_rewrite_template_arg_in_rewrite_template_args3167);
+ rewrite_template_arg191=rewrite_template_arg();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_rewrite_template_arg.add(rewrite_template_arg191.getTree());
+
+ }
+ break;
+
+ default :
+ break loop82;
+ }
+ } while (true);
+
+
+
+ // AST REWRITE
+ // elements: rewrite_template_arg
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 455:3: -> ^( ARGLIST ( rewrite_template_arg )+ )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:455:6: ^( ARGLIST ( rewrite_template_arg )+ )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ARGLIST, "ARGLIST"), root_1);
+
+ if ( !(stream_rewrite_template_arg.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_rewrite_template_arg.hasNext() ) {
+ adaptor.addChild(root_1, stream_rewrite_template_arg.nextTree());
+
+ }
+ stream_rewrite_template_arg.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:456:4:
+ {
+
+ // AST REWRITE
+ // elements:
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 456:4: -> ARGLIST
+ {
+ adaptor.addChild(root_0, (CommonTree)adaptor.create(ARGLIST, "ARGLIST"));
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+
+ }
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "rewrite_template_args"
+
+ public static class rewrite_template_arg_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "rewrite_template_arg"
+ // org/antlr/grammar/v3/ANTLRv3.g:459:1: rewrite_template_arg : id '=' ACTION -> ^( ARG[$id.start] id ACTION ) ;
+ public final ANTLRv3Parser.rewrite_template_arg_return rewrite_template_arg() throws RecognitionException {
+ ANTLRv3Parser.rewrite_template_arg_return retval = new ANTLRv3Parser.rewrite_template_arg_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token char_literal193=null;
+ Token ACTION194=null;
+ ANTLRv3Parser.id_return id192 = null;
+
+
+ CommonTree char_literal193_tree=null;
+ CommonTree ACTION194_tree=null;
+ RewriteRuleTokenStream stream_LABEL_ASSIGN=new RewriteRuleTokenStream(adaptor,"token LABEL_ASSIGN");
+ RewriteRuleTokenStream stream_ACTION=new RewriteRuleTokenStream(adaptor,"token ACTION");
+ RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:460:2: ( id '=' ACTION -> ^( ARG[$id.start] id ACTION ) )
+ // org/antlr/grammar/v3/ANTLRv3.g:460:6: id '=' ACTION
+ {
+ pushFollow(FOLLOW_id_in_rewrite_template_arg3200);
+ id192=id();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_id.add(id192.getTree());
+ char_literal193=(Token)match(input,LABEL_ASSIGN,FOLLOW_LABEL_ASSIGN_in_rewrite_template_arg3202); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_LABEL_ASSIGN.add(char_literal193);
+
+ ACTION194=(Token)match(input,ACTION,FOLLOW_ACTION_in_rewrite_template_arg3204); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_ACTION.add(ACTION194);
+
+
+
+ // AST REWRITE
+ // elements: id, ACTION
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 460:20: -> ^( ARG[$id.start] id ACTION )
+ {
+ // org/antlr/grammar/v3/ANTLRv3.g:460:23: ^( ARG[$id.start] id ACTION )
+ {
+ CommonTree root_1 = (CommonTree)adaptor.nil();
+ root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ARG, (id192!=null?((Token)id192.start):null)), root_1);
+
+ adaptor.addChild(root_1, stream_id.nextTree());
+ adaptor.addChild(root_1, stream_ACTION.nextNode());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0;}
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "rewrite_template_arg"
+
+ public static class qid_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "qid"
+ // org/antlr/grammar/v3/ANTLRv3.g:463:1: qid : id ( '.' id )* ;
+ public final ANTLRv3Parser.qid_return qid() throws RecognitionException {
+ ANTLRv3Parser.qid_return retval = new ANTLRv3Parser.qid_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token char_literal196=null;
+ ANTLRv3Parser.id_return id195 = null;
+
+ ANTLRv3Parser.id_return id197 = null;
+
+
+ CommonTree char_literal196_tree=null;
+
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:463:5: ( id ( '.' id )* )
+ // org/antlr/grammar/v3/ANTLRv3.g:463:7: id ( '.' id )*
+ {
+ root_0 = (CommonTree)adaptor.nil();
+
+ pushFollow(FOLLOW_id_in_qid3225);
+ id195=id();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) adaptor.addChild(root_0, id195.getTree());
+ // org/antlr/grammar/v3/ANTLRv3.g:463:10: ( '.' id )*
+ loop84:
+ do {
+ int alt84=2;
+ int LA84_0 = input.LA(1);
+
+ if ( (LA84_0==90) ) {
+ alt84=1;
+ }
+
+
+ switch (alt84) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:463:11: '.' id
+ {
+ char_literal196=(Token)match(input,90,FOLLOW_90_in_qid3228); if (state.failed) return retval;
+ if ( state.backtracking==0 ) {
+ char_literal196_tree = (CommonTree)adaptor.create(char_literal196);
+ adaptor.addChild(root_0, char_literal196_tree);
+ }
+ pushFollow(FOLLOW_id_in_qid3230);
+ id197=id();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) adaptor.addChild(root_0, id197.getTree());
+
+ }
+ break;
+
+ default :
+ break loop84;
+ }
+ } while (true);
+
+
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "qid"
+
+ public static class id_return extends ParserRuleReturnScope {
+ CommonTree tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start "id"
+ // org/antlr/grammar/v3/ANTLRv3.g:465:1: id : ( TOKEN_REF -> ID[$TOKEN_REF] | RULE_REF -> ID[$RULE_REF] );
+ public final ANTLRv3Parser.id_return id() throws RecognitionException {
+ ANTLRv3Parser.id_return retval = new ANTLRv3Parser.id_return();
+ retval.start = input.LT(1);
+
+ CommonTree root_0 = null;
+
+ Token TOKEN_REF198=null;
+ Token RULE_REF199=null;
+
+ CommonTree TOKEN_REF198_tree=null;
+ CommonTree RULE_REF199_tree=null;
+ RewriteRuleTokenStream stream_RULE_REF=new RewriteRuleTokenStream(adaptor,"token RULE_REF");
+ RewriteRuleTokenStream stream_TOKEN_REF=new RewriteRuleTokenStream(adaptor,"token TOKEN_REF");
+
+ try {
+ // org/antlr/grammar/v3/ANTLRv3.g:465:4: ( TOKEN_REF -> ID[$TOKEN_REF] | RULE_REF -> ID[$RULE_REF] )
+ int alt85=2;
+ int LA85_0 = input.LA(1);
+
+ if ( (LA85_0==TOKEN_REF) ) {
+ alt85=1;
+ }
+ else if ( (LA85_0==RULE_REF) ) {
+ alt85=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 85, 0, input);
+
+ throw nvae;
+ }
+ switch (alt85) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3.g:465:6: TOKEN_REF
+ {
+ TOKEN_REF198=(Token)match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_id3242); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_TOKEN_REF.add(TOKEN_REF198);
+
+
+
+ // AST REWRITE
+ // elements:
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 465:16: -> ID[$TOKEN_REF]
+ {
+ adaptor.addChild(root_0, (CommonTree)adaptor.create(ID, TOKEN_REF198));
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3.g:466:4: RULE_REF
+ {
+ RULE_REF199=(Token)match(input,RULE_REF,FOLLOW_RULE_REF_in_id3252); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_RULE_REF.add(RULE_REF199);
+
+
+
+ // AST REWRITE
+ // elements:
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (CommonTree)adaptor.nil();
+ // 466:14: -> ID[$RULE_REF]
+ {
+ adaptor.addChild(root_0, (CommonTree)adaptor.create(ID, RULE_REF199));
+
+ }
+
+ retval.tree = root_0;}
+ }
+ break;
+
+ }
+ retval.stop = input.LT(-1);
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end "id"
+
+ // $ANTLR start synpred1_ANTLRv3
+ public final void synpred1_ANTLRv3_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ANTLRv3.g:363:4: ( rewrite_template )
+ // org/antlr/grammar/v3/ANTLRv3.g:363:4: rewrite_template
+ {
+ pushFollow(FOLLOW_rewrite_template_in_synpred1_ANTLRv32649);
+ rewrite_template();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred1_ANTLRv3
+
+ // $ANTLR start synpred2_ANTLRv3
+ public final void synpred2_ANTLRv3_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ANTLRv3.g:364:4: ( rewrite_tree_alternative )
+ // org/antlr/grammar/v3/ANTLRv3.g:364:4: rewrite_tree_alternative
+ {
+ pushFollow(FOLLOW_rewrite_tree_alternative_in_synpred2_ANTLRv32654);
+ rewrite_tree_alternative();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred2_ANTLRv3
+
+ // Delegated rules
+
+ public final boolean synpred2_ANTLRv3() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred2_ANTLRv3_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred1_ANTLRv3() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred1_ANTLRv3_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+
+
+ protected DFA46 dfa46 = new DFA46(this);
+ protected DFA73 dfa73 = new DFA73(this);
+ protected DFA76 dfa76 = new DFA76(this);
+ protected DFA81 dfa81 = new DFA81(this);
+ static final String DFA46_eotS =
+ "\14\uffff";
+ static final String DFA46_eofS =
+ "\14\uffff";
+ static final String DFA46_minS =
+ "\3\37\5\uffff\2\54\2\uffff";
+ static final String DFA46_maxS =
+ "\1\132\2\134\5\uffff\2\132\2\uffff";
+ static final String DFA46_acceptS =
+ "\3\uffff\1\3\1\4\1\5\1\6\1\7\2\uffff\1\2\1\1";
+ static final String DFA46_specialS =
+ "\14\uffff}>";
+ static final String[] DFA46_transitionS = {
+ "\1\6\4\uffff\1\7\7\uffff\1\1\2\3\1\5\3\uffff\1\2\35\uffff\1"+
+ "\4\5\uffff\1\3\2\uffff\1\3",
+ "\1\3\4\uffff\4\3\1\uffff\1\10\1\11\1\uffff\4\3\2\uffff\2\3"+
+ "\23\uffff\1\3\2\uffff\1\3\6\uffff\3\3\3\uffff\2\3\1\uffff\3"+
+ "\3",
+ "\1\3\4\uffff\4\3\1\uffff\1\10\1\11\1\uffff\4\3\2\uffff\2\3"+
+ "\23\uffff\1\3\2\uffff\1\3\6\uffff\3\3\3\uffff\1\3\2\uffff\3"+
+ "\3",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\3\13\4\uffff\1\13\35\uffff\1\12\5\uffff\1\13\2\uffff\1\13",
+ "\3\13\4\uffff\1\13\35\uffff\1\12\5\uffff\1\13\2\uffff\1\13",
+ "",
+ ""
+ };
+
+ static final short[] DFA46_eot = DFA.unpackEncodedString(DFA46_eotS);
+ static final short[] DFA46_eof = DFA.unpackEncodedString(DFA46_eofS);
+ static final char[] DFA46_min = DFA.unpackEncodedStringToUnsignedChars(DFA46_minS);
+ static final char[] DFA46_max = DFA.unpackEncodedStringToUnsignedChars(DFA46_maxS);
+ static final short[] DFA46_accept = DFA.unpackEncodedString(DFA46_acceptS);
+ static final short[] DFA46_special = DFA.unpackEncodedString(DFA46_specialS);
+ static final short[][] DFA46_transition;
+
+ static {
+ int numStates = DFA46_transitionS.length;
+ DFA46_transition = new short[numStates][];
+ for (int i=0; i<numStates; i++) {
+ DFA46_transition[i] = DFA.unpackEncodedString(DFA46_transitionS[i]);
+ }
+ }
+
+ class DFA46 extends DFA {
+
+ public DFA46(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 46;
+ this.eot = DFA46_eot;
+ this.eof = DFA46_eof;
+ this.min = DFA46_min;
+ this.max = DFA46_max;
+ this.accept = DFA46_accept;
+ this.special = DFA46_special;
+ this.transition = DFA46_transition;
+ }
+ public String getDescription() {
+ return "234:1: element : ( id (labelOp= '=' | labelOp= '+=' ) atom ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] ^( $labelOp id atom ) EOA[\"EOA\"] ) EOB[\"EOB\"] ) ) | -> ^( $labelOp id atom ) ) | id (labelOp= '=' | labelOp= '+=' ) block ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] ^( $labelOp id block ) EOA[\"EOA\"] ) EOB[\"EOB\"] ) ) | -> ^( $labelOp id block ) ) | atom ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\ [...]
+ }
+ }
+ static final String DFA73_eotS =
+ "\15\uffff";
+ static final String DFA73_eofS =
+ "\15\uffff";
+ static final String DFA73_minS =
+ "\4\44\1\0\2\uffff\2\44\1\uffff\2\44\1\112";
+ static final String DFA73_maxS =
+ "\4\135\1\0\2\uffff\2\135\1\uffff\2\135\1\134";
+ static final String DFA73_acceptS =
+ "\5\uffff\1\2\1\3\2\uffff\1\1\3\uffff";
+ static final String DFA73_specialS =
+ "\4\uffff\1\0\10\uffff}>";
+ static final String[] DFA73_transitionS = {
+ "\1\5\2\uffff\1\6\4\uffff\1\1\2\5\1\4\3\uffff\1\2\23\uffff\1"+
+ "\6\11\uffff\1\3\2\6\11\uffff\1\5",
+ "\1\5\2\uffff\1\5\4\uffff\4\5\2\uffff\2\5\23\uffff\1\5\2\uffff"+
+ "\1\5\6\uffff\1\7\2\5\7\uffff\3\5",
+ "\1\5\2\uffff\1\5\4\uffff\4\5\3\uffff\1\5\23\uffff\1\5\2\uffff"+
+ "\1\5\6\uffff\1\7\2\5\7\uffff\3\5",
+ "\1\5\7\uffff\3\5\1\10\3\uffff\1\5\35\uffff\1\5\13\uffff\1\5",
+ "\1\uffff",
+ "",
+ "",
+ "\1\5\7\uffff\1\12\3\5\3\uffff\1\13\35\uffff\1\5\1\uffff\1\11"+
+ "\11\uffff\1\5",
+ "\1\5\7\uffff\4\5\3\uffff\1\5\26\uffff\1\5\6\uffff\1\5\1\uffff"+
+ "\1\14\7\uffff\3\5",
+ "",
+ "\1\5\4\uffff\1\11\2\uffff\4\5\2\uffff\2\5\26\uffff\1\5\6\uffff"+
+ "\1\5\1\uffff\1\5\7\uffff\3\5",
+ "\1\5\4\uffff\1\11\2\uffff\4\5\3\uffff\1\5\26\uffff\1\5\6\uffff"+
+ "\1\5\1\uffff\1\5\7\uffff\3\5",
+ "\1\5\6\uffff\1\11\11\uffff\2\5"
+ };
+
+ static final short[] DFA73_eot = DFA.unpackEncodedString(DFA73_eotS);
+ static final short[] DFA73_eof = DFA.unpackEncodedString(DFA73_eofS);
+ static final char[] DFA73_min = DFA.unpackEncodedStringToUnsignedChars(DFA73_minS);
+ static final char[] DFA73_max = DFA.unpackEncodedStringToUnsignedChars(DFA73_maxS);
+ static final short[] DFA73_accept = DFA.unpackEncodedString(DFA73_acceptS);
+ static final short[] DFA73_special = DFA.unpackEncodedString(DFA73_specialS);
+ static final short[][] DFA73_transition;
+
+ static {
+ int numStates = DFA73_transitionS.length;
+ DFA73_transition = new short[numStates][];
+ for (int i=0; i<numStates; i++) {
+ DFA73_transition[i] = DFA.unpackEncodedString(DFA73_transitionS[i]);
+ }
+ }
+
+ class DFA73 extends DFA {
+
+ public DFA73(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 73;
+ this.eot = DFA73_eot;
+ this.eof = DFA73_eof;
+ this.min = DFA73_min;
+ this.max = DFA73_max;
+ this.accept = DFA73_accept;
+ this.special = DFA73_special;
+ this.transition = DFA73_transition;
+ }
+ public String getDescription() {
+ return "361:1: rewrite_alternative options {backtrack=true; } : ( rewrite_template | rewrite_tree_alternative | -> ^( ALT[\"ALT\"] EPSILON[\"EPSILON\"] EOA[\"EOA\"] ) );";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA73_4 = input.LA(1);
+
+
+ int index73_4 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred1_ANTLRv3()) ) {s = 9;}
+
+ else if ( (synpred2_ANTLRv3()) ) {s = 5;}
+
+
+ input.seek(index73_4);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 73, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String DFA76_eotS =
+ "\16\uffff";
+ static final String DFA76_eofS =
+ "\1\uffff\4\12\1\uffff\1\12\4\uffff\3\12";
+ static final String DFA76_minS =
+ "\5\44\1\54\1\44\4\uffff\3\44";
+ static final String DFA76_maxS =
+ "\5\135\1\63\1\135\4\uffff\3\135";
+ static final String DFA76_acceptS =
+ "\7\uffff\1\3\1\4\1\2\1\1\3\uffff";
+ static final String DFA76_specialS =
+ "\16\uffff}>";
+ static final String[] DFA76_transitionS = {
+ "\1\7\7\uffff\1\2\1\4\1\1\1\6\3\uffff\1\3\35\uffff\1\10\13\uffff"+
+ "\1\5",
+ "\1\12\2\uffff\1\12\4\uffff\4\12\3\uffff\1\12\23\uffff\1\12"+
+ "\2\uffff\1\11\6\uffff\3\12\7\uffff\2\11\1\12",
+ "\1\12\2\uffff\1\12\4\uffff\4\12\2\uffff\1\13\1\12\23\uffff"+
+ "\1\12\2\uffff\1\11\6\uffff\3\12\7\uffff\2\11\1\12",
+ "\1\12\2\uffff\1\12\4\uffff\4\12\3\uffff\1\12\23\uffff\1\12"+
+ "\2\uffff\1\11\6\uffff\3\12\7\uffff\2\11\1\12",
+ "\1\12\2\uffff\1\12\4\uffff\4\12\3\uffff\1\12\23\uffff\1\12"+
+ "\2\uffff\1\11\6\uffff\3\12\7\uffff\2\11\1\12",
+ "\1\14\6\uffff\1\15",
+ "\1\12\2\uffff\1\12\4\uffff\4\12\3\uffff\1\12\23\uffff\1\12"+
+ "\2\uffff\1\11\6\uffff\3\12\7\uffff\2\11\1\12",
+ "",
+ "",
+ "",
+ "",
+ "\1\12\2\uffff\1\12\4\uffff\4\12\3\uffff\1\12\23\uffff\1\12"+
+ "\2\uffff\1\11\6\uffff\3\12\7\uffff\2\11\1\12",
+ "\1\12\2\uffff\1\12\4\uffff\4\12\3\uffff\1\12\23\uffff\1\12"+
+ "\2\uffff\1\11\6\uffff\3\12\7\uffff\2\11\1\12",
+ "\1\12\2\uffff\1\12\4\uffff\4\12\3\uffff\1\12\23\uffff\1\12"+
+ "\2\uffff\1\11\6\uffff\3\12\7\uffff\2\11\1\12"
+ };
+
+ static final short[] DFA76_eot = DFA.unpackEncodedString(DFA76_eotS);
+ static final short[] DFA76_eof = DFA.unpackEncodedString(DFA76_eofS);
+ static final char[] DFA76_min = DFA.unpackEncodedStringToUnsignedChars(DFA76_minS);
+ static final char[] DFA76_max = DFA.unpackEncodedStringToUnsignedChars(DFA76_maxS);
+ static final short[] DFA76_accept = DFA.unpackEncodedString(DFA76_acceptS);
+ static final short[] DFA76_special = DFA.unpackEncodedString(DFA76_specialS);
+ static final short[][] DFA76_transition;
+
+ static {
+ int numStates = DFA76_transitionS.length;
+ DFA76_transition = new short[numStates][];
+ for (int i=0; i<numStates; i++) {
+ DFA76_transition[i] = DFA.unpackEncodedString(DFA76_transitionS[i]);
+ }
+ }
+
+ class DFA76 extends DFA {
+
+ public DFA76(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 76;
+ this.eot = DFA76_eot;
+ this.eof = DFA76_eof;
+ this.min = DFA76_min;
+ this.max = DFA76_max;
+ this.accept = DFA76_accept;
+ this.special = DFA76_special;
+ this.transition = DFA76_transition;
+ }
+ public String getDescription() {
+ return "377:1: rewrite_tree_element : ( rewrite_tree_atom | rewrite_tree_atom ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] rewrite_tree_atom EOA[\"EOA\"] ) EOB[\"EOB\"] ) ) | rewrite_tree ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[\"BLOCK\"] ^( ALT[\"ALT\"] rewrite_tree EOA[\"EOA\"] ) EOB[\"EOB\"] ) ) | -> rewrite_tree ) | rewrite_tree_ebnf );";
+ }
+ }
+ static final String DFA81_eotS =
+ "\22\uffff";
+ static final String DFA81_eofS =
+ "\10\uffff\1\12\11\uffff";
+ static final String DFA81_minS =
+ "\1\54\2\121\2\uffff\1\54\2\51\1\47\1\57\2\uffff\1\120\1\54\2\51"+
+ "\1\57\1\120";
+ static final String DFA81_maxS =
+ "\3\121\2\uffff\1\123\2\51\1\123\1\57\2\uffff\1\123\1\63\2\51\1\57"+
+ "\1\123";
+ static final String DFA81_acceptS =
+ "\3\uffff\1\3\1\4\5\uffff\1\2\1\1\6\uffff";
+ static final String DFA81_specialS =
+ "\22\uffff}>";
+ static final String[] DFA81_transitionS = {
+ "\1\1\2\uffff\1\4\3\uffff\1\2\35\uffff\1\3",
+ "\1\5",
+ "\1\5",
+ "",
+ "",
+ "\1\6\6\uffff\1\7\37\uffff\1\10",
+ "\1\11",
+ "\1\11",
+ "\1\12\14\uffff\2\13\21\uffff\1\12\12\uffff\2\12",
+ "\1\14",
+ "",
+ "",
+ "\1\15\2\uffff\1\10",
+ "\1\16\6\uffff\1\17",
+ "\1\20",
+ "\1\20",
+ "\1\21",
+ "\1\15\2\uffff\1\10"
+ };
+
+ static final short[] DFA81_eot = DFA.unpackEncodedString(DFA81_eotS);
+ static final short[] DFA81_eof = DFA.unpackEncodedString(DFA81_eofS);
+ static final char[] DFA81_min = DFA.unpackEncodedStringToUnsignedChars(DFA81_minS);
+ static final char[] DFA81_max = DFA.unpackEncodedStringToUnsignedChars(DFA81_maxS);
+ static final short[] DFA81_accept = DFA.unpackEncodedString(DFA81_acceptS);
+ static final short[] DFA81_special = DFA.unpackEncodedString(DFA81_specialS);
+ static final short[][] DFA81_transition;
+
+ static {
+ int numStates = DFA81_transitionS.length;
+ DFA81_transition = new short[numStates][];
+ for (int i=0; i<numStates; i++) {
+ DFA81_transition[i] = DFA.unpackEncodedString(DFA81_transitionS[i]);
+ }
+ }
+
+ class DFA81 extends DFA {
+
+ public DFA81(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 81;
+ this.eot = DFA81_eot;
+ this.eof = DFA81_eof;
+ this.min = DFA81_min;
+ this.max = DFA81_max;
+ this.accept = DFA81_accept;
+ this.special = DFA81_special;
+ this.transition = DFA81_transition;
+ }
+ public String getDescription() {
+ return "414:1: rewrite_template : ( id lp= '(' rewrite_template_args ')' (str= DOUBLE_QUOTE_STRING_LITERAL | str= DOUBLE_ANGLE_STRING_LITERAL ) -> ^( TEMPLATE[$lp,\"TEMPLATE\"] id rewrite_template_args $str) | rewrite_template_ref | rewrite_indirect_template_head | ACTION );";
+ }
+ }
+
+
+ public static final BitSet FOLLOW_DOC_COMMENT_in_grammarDef368 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000078L});
+ public static final BitSet FOLLOW_67_in_grammarDef378 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
+ public static final BitSet FOLLOW_68_in_grammarDef396 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
+ public static final BitSet FOLLOW_69_in_grammarDef412 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
+ public static final BitSet FOLLOW_70_in_grammarDef453 = new BitSet(new long[]{0x0008100000000000L});
+ public static final BitSet FOLLOW_id_in_grammarDef455 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
+ public static final BitSet FOLLOW_71_in_grammarDef457 = new BitSet(new long[]{0x0009190840000010L,0x0000000000003800L});
+ public static final BitSet FOLLOW_optionsSpec_in_grammarDef459 = new BitSet(new long[]{0x0009190840000010L,0x0000000000003800L});
+ public static final BitSet FOLLOW_tokensSpec_in_grammarDef462 = new BitSet(new long[]{0x0009190840000010L,0x0000000000003800L});
+ public static final BitSet FOLLOW_attrScope_in_grammarDef465 = new BitSet(new long[]{0x0009190840000010L,0x0000000000003800L});
+ public static final BitSet FOLLOW_action_in_grammarDef468 = new BitSet(new long[]{0x0009190840000010L,0x0000000000003800L});
+ public static final BitSet FOLLOW_rule_in_grammarDef476 = new BitSet(new long[]{0x0009190840000010L,0x0000000000003800L});
+ public static final BitSet FOLLOW_EOF_in_grammarDef484 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_TOKENS_in_tokensSpec545 = new BitSet(new long[]{0x0000100000000000L});
+ public static final BitSet FOLLOW_tokenSpec_in_tokensSpec547 = new BitSet(new long[]{0x0000100000000000L,0x0000000000000100L});
+ public static final BitSet FOLLOW_72_in_tokensSpec550 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_TOKEN_REF_in_tokenSpec570 = new BitSet(new long[]{0x0000020000000000L,0x0000000000000080L});
+ public static final BitSet FOLLOW_LABEL_ASSIGN_in_tokenSpec576 = new BitSet(new long[]{0x0000600000000000L});
+ public static final BitSet FOLLOW_STRING_LITERAL_in_tokenSpec581 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
+ public static final BitSet FOLLOW_CHAR_LITERAL_in_tokenSpec585 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
+ public static final BitSet FOLLOW_71_in_tokenSpec624 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_SCOPE_in_attrScope635 = new BitSet(new long[]{0x0008100000000000L});
+ public static final BitSet FOLLOW_id_in_attrScope637 = new BitSet(new long[]{0x0000800000000000L});
+ public static final BitSet FOLLOW_ACTION_in_attrScope639 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_AT_in_action662 = new BitSet(new long[]{0x0008100000000000L,0x0000000000000018L});
+ public static final BitSet FOLLOW_actionScopeName_in_action665 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000200L});
+ public static final BitSet FOLLOW_73_in_action667 = new BitSet(new long[]{0x0008100000000000L});
+ public static final BitSet FOLLOW_id_in_action671 = new BitSet(new long[]{0x0000800000000000L});
+ public static final BitSet FOLLOW_ACTION_in_action673 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_id_in_actionScopeName699 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_67_in_actionScopeName706 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_68_in_actionScopeName723 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_OPTIONS_in_optionsSpec739 = new BitSet(new long[]{0x0008100000000000L});
+ public static final BitSet FOLLOW_option_in_optionsSpec742 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
+ public static final BitSet FOLLOW_71_in_optionsSpec744 = new BitSet(new long[]{0x0008100000000000L,0x0000000000000100L});
+ public static final BitSet FOLLOW_72_in_optionsSpec748 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_id_in_option773 = new BitSet(new long[]{0x0000020000000000L});
+ public static final BitSet FOLLOW_LABEL_ASSIGN_in_option775 = new BitSet(new long[]{0x000A700000000000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_optionValue_in_option777 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_qid_in_optionValue806 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_STRING_LITERAL_in_optionValue816 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_CHAR_LITERAL_in_optionValue826 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_INT_in_optionValue836 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_74_in_optionValue846 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_DOC_COMMENT_in_rule871 = new BitSet(new long[]{0x0008100800000000L,0x0000000000003800L});
+ public static final BitSet FOLLOW_75_in_rule881 = new BitSet(new long[]{0x0008100000000000L});
+ public static final BitSet FOLLOW_76_in_rule883 = new BitSet(new long[]{0x0008100000000000L});
+ public static final BitSet FOLLOW_77_in_rule885 = new BitSet(new long[]{0x0008100000000000L});
+ public static final BitSet FOLLOW_FRAGMENT_in_rule887 = new BitSet(new long[]{0x0008100000000000L});
+ public static final BitSet FOLLOW_id_in_rule895 = new BitSet(new long[]{0x0005014040800000L,0x000000000000C000L});
+ public static final BitSet FOLLOW_BANG_in_rule901 = new BitSet(new long[]{0x0005010040800000L,0x000000000000C000L});
+ public static final BitSet FOLLOW_ARG_ACTION_in_rule910 = new BitSet(new long[]{0x0001010040800000L,0x000000000000C000L});
+ public static final BitSet FOLLOW_RET_in_rule919 = new BitSet(new long[]{0x0004000000000000L});
+ public static final BitSet FOLLOW_ARG_ACTION_in_rule923 = new BitSet(new long[]{0x0001010040000000L,0x000000000000C000L});
+ public static final BitSet FOLLOW_throwsSpec_in_rule931 = new BitSet(new long[]{0x0001010040000000L,0x0000000000004000L});
+ public static final BitSet FOLLOW_optionsSpec_in_rule934 = new BitSet(new long[]{0x0000010040000000L,0x0000000000004000L});
+ public static final BitSet FOLLOW_ruleScopeSpec_in_rule937 = new BitSet(new long[]{0x0000010000000000L,0x0000000000004000L});
+ public static final BitSet FOLLOW_ruleAction_in_rule940 = new BitSet(new long[]{0x0000010000000000L,0x0000000000004000L});
+ public static final BitSet FOLLOW_78_in_rule945 = new BitSet(new long[]{0x0008F09080000000L,0x0000000004820000L});
+ public static final BitSet FOLLOW_altList_in_rule947 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
+ public static final BitSet FOLLOW_71_in_rule949 = new BitSet(new long[]{0x0000000000000002L,0x0000000000300000L});
+ public static final BitSet FOLLOW_exceptionGroup_in_rule953 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_AT_in_ruleAction1059 = new BitSet(new long[]{0x0008100000000000L});
+ public static final BitSet FOLLOW_id_in_ruleAction1061 = new BitSet(new long[]{0x0000800000000000L});
+ public static final BitSet FOLLOW_ACTION_in_ruleAction1063 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_79_in_throwsSpec1084 = new BitSet(new long[]{0x0008100000000000L});
+ public static final BitSet FOLLOW_id_in_throwsSpec1086 = new BitSet(new long[]{0x0000000000000002L,0x0000000000010000L});
+ public static final BitSet FOLLOW_80_in_throwsSpec1090 = new BitSet(new long[]{0x0008100000000000L});
+ public static final BitSet FOLLOW_id_in_throwsSpec1092 = new BitSet(new long[]{0x0000000000000002L,0x0000000000010000L});
+ public static final BitSet FOLLOW_SCOPE_in_ruleScopeSpec1115 = new BitSet(new long[]{0x0000800000000000L});
+ public static final BitSet FOLLOW_ACTION_in_ruleScopeSpec1117 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_SCOPE_in_ruleScopeSpec1130 = new BitSet(new long[]{0x0008100000000000L});
+ public static final BitSet FOLLOW_id_in_ruleScopeSpec1132 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010080L});
+ public static final BitSet FOLLOW_80_in_ruleScopeSpec1135 = new BitSet(new long[]{0x0008100000000000L});
+ public static final BitSet FOLLOW_id_in_ruleScopeSpec1137 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010080L});
+ public static final BitSet FOLLOW_71_in_ruleScopeSpec1141 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_SCOPE_in_ruleScopeSpec1155 = new BitSet(new long[]{0x0000800000000000L});
+ public static final BitSet FOLLOW_ACTION_in_ruleScopeSpec1157 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_SCOPE_in_ruleScopeSpec1161 = new BitSet(new long[]{0x0008100000000000L});
+ public static final BitSet FOLLOW_id_in_ruleScopeSpec1163 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010080L});
+ public static final BitSet FOLLOW_80_in_ruleScopeSpec1166 = new BitSet(new long[]{0x0008100000000000L});
+ public static final BitSet FOLLOW_id_in_ruleScopeSpec1168 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010080L});
+ public static final BitSet FOLLOW_71_in_ruleScopeSpec1172 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_81_in_block1204 = new BitSet(new long[]{0x0009F09080000000L,0x0000000004824000L});
+ public static final BitSet FOLLOW_optionsSpec_in_block1213 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
+ public static final BitSet FOLLOW_78_in_block1217 = new BitSet(new long[]{0x0008F09080000000L,0x0000000004820000L});
+ public static final BitSet FOLLOW_altpair_in_block1224 = new BitSet(new long[]{0x0000000000000000L,0x00000000000C0000L});
+ public static final BitSet FOLLOW_82_in_block1228 = new BitSet(new long[]{0x0008F09080000000L,0x0000000004820000L});
+ public static final BitSet FOLLOW_altpair_in_block1230 = new BitSet(new long[]{0x0000000000000000L,0x00000000000C0000L});
+ public static final BitSet FOLLOW_83_in_block1245 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_alternative_in_altpair1284 = new BitSet(new long[]{0x0000008000000000L});
+ public static final BitSet FOLLOW_rewrite_in_altpair1286 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_altpair_in_altList1306 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L});
+ public static final BitSet FOLLOW_82_in_altList1310 = new BitSet(new long[]{0x0008F09080000000L,0x0000000004820000L});
+ public static final BitSet FOLLOW_altpair_in_altList1312 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L});
+ public static final BitSet FOLLOW_element_in_alternative1353 = new BitSet(new long[]{0x0008F01080000002L,0x0000000004820000L});
+ public static final BitSet FOLLOW_exceptionHandler_in_exceptionGroup1404 = new BitSet(new long[]{0x0000000000000002L,0x0000000000300000L});
+ public static final BitSet FOLLOW_finallyClause_in_exceptionGroup1411 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_finallyClause_in_exceptionGroup1419 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_84_in_exceptionHandler1439 = new BitSet(new long[]{0x0004000000000000L});
+ public static final BitSet FOLLOW_ARG_ACTION_in_exceptionHandler1441 = new BitSet(new long[]{0x0000800000000000L});
+ public static final BitSet FOLLOW_ACTION_in_exceptionHandler1443 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_85_in_finallyClause1473 = new BitSet(new long[]{0x0000800000000000L});
+ public static final BitSet FOLLOW_ACTION_in_finallyClause1475 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_id_in_element1497 = new BitSet(new long[]{0x0000060000000000L});
+ public static final BitSet FOLLOW_LABEL_ASSIGN_in_element1502 = new BitSet(new long[]{0x0008700000000000L,0x0000000004800000L});
+ public static final BitSet FOLLOW_LIST_LABEL_ASSIGN_in_element1506 = new BitSet(new long[]{0x0008700000000000L,0x0000000004800000L});
+ public static final BitSet FOLLOW_atom_in_element1509 = new BitSet(new long[]{0x0000000000000002L,0x0000000018000400L});
+ public static final BitSet FOLLOW_ebnfSuffix_in_element1515 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_id_in_element1574 = new BitSet(new long[]{0x0000060000000000L});
+ public static final BitSet FOLLOW_LABEL_ASSIGN_in_element1579 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L});
+ public static final BitSet FOLLOW_LIST_LABEL_ASSIGN_in_element1583 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L});
+ public static final BitSet FOLLOW_block_in_element1586 = new BitSet(new long[]{0x0000000000000002L,0x0000000018000400L});
+ public static final BitSet FOLLOW_ebnfSuffix_in_element1592 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_atom_in_element1651 = new BitSet(new long[]{0x0000000000000002L,0x0000000018000400L});
+ public static final BitSet FOLLOW_ebnfSuffix_in_element1657 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ebnf_in_element1703 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ACTION_in_element1710 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_SEMPRED_in_element1717 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L});
+ public static final BitSet FOLLOW_86_in_element1723 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_treeSpec_in_element1743 = new BitSet(new long[]{0x0000000000000002L,0x0000000018000400L});
+ public static final BitSet FOLLOW_ebnfSuffix_in_element1749 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_terminal_in_atom1801 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_range_in_atom1806 = new BitSet(new long[]{0x0000006000000002L});
+ public static final BitSet FOLLOW_ROOT_in_atom1816 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_BANG_in_atom1820 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_notSet_in_atom1854 = new BitSet(new long[]{0x0000006000000002L});
+ public static final BitSet FOLLOW_ROOT_in_atom1863 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_BANG_in_atom1867 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_REF_in_atom1903 = new BitSet(new long[]{0x0004006000000002L});
+ public static final BitSet FOLLOW_ARG_ACTION_in_atom1905 = new BitSet(new long[]{0x0000006000000002L});
+ public static final BitSet FOLLOW_ROOT_in_atom1915 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_BANG_in_atom1919 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_87_in_notSet1967 = new BitSet(new long[]{0x0000700000000000L,0x0000000000020000L});
+ public static final BitSet FOLLOW_notTerminal_in_notSet1973 = new BitSet(new long[]{0x0000000000000002L,0x0000000001000000L});
+ public static final BitSet FOLLOW_elementOptions_in_notSet1975 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_block_in_notSet1993 = new BitSet(new long[]{0x0000000000000002L,0x0000000001000000L});
+ public static final BitSet FOLLOW_elementOptions_in_notSet1995 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_set_in_notTerminal0 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_88_in_elementOptions2047 = new BitSet(new long[]{0x0008100000000000L});
+ public static final BitSet FOLLOW_qid_in_elementOptions2049 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L});
+ public static final BitSet FOLLOW_89_in_elementOptions2051 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_88_in_elementOptions2069 = new BitSet(new long[]{0x0008100000000000L});
+ public static final BitSet FOLLOW_option_in_elementOptions2071 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000080L});
+ public static final BitSet FOLLOW_71_in_elementOptions2074 = new BitSet(new long[]{0x0008100000000000L});
+ public static final BitSet FOLLOW_option_in_elementOptions2076 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000080L});
+ public static final BitSet FOLLOW_89_in_elementOptions2080 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_id_in_elementOption2100 = new BitSet(new long[]{0x0000020000000000L});
+ public static final BitSet FOLLOW_LABEL_ASSIGN_in_elementOption2102 = new BitSet(new long[]{0x000A700000000000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_optionValue_in_elementOption2104 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_TREE_BEGIN_in_treeSpec2126 = new BitSet(new long[]{0x0008F01080000000L,0x0000000004820000L});
+ public static final BitSet FOLLOW_element_in_treeSpec2128 = new BitSet(new long[]{0x0008F01080000000L,0x0000000004820000L});
+ public static final BitSet FOLLOW_element_in_treeSpec2132 = new BitSet(new long[]{0x0008F01080000000L,0x00000000048A0000L});
+ public static final BitSet FOLLOW_83_in_treeSpec2137 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_CHAR_LITERAL_in_range2160 = new BitSet(new long[]{0x0000000000002000L});
+ public static final BitSet FOLLOW_RANGE_in_range2162 = new BitSet(new long[]{0x0000400000000000L});
+ public static final BitSet FOLLOW_CHAR_LITERAL_in_range2166 = new BitSet(new long[]{0x0000000000000002L,0x0000000001000000L});
+ public static final BitSet FOLLOW_elementOptions_in_range2168 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_CHAR_LITERAL_in_terminal2205 = new BitSet(new long[]{0x0000006000000002L,0x0000000001000000L});
+ public static final BitSet FOLLOW_elementOptions_in_terminal2207 = new BitSet(new long[]{0x0000006000000002L});
+ public static final BitSet FOLLOW_TOKEN_REF_in_terminal2238 = new BitSet(new long[]{0x0004006000000002L,0x0000000001000000L});
+ public static final BitSet FOLLOW_ARG_ACTION_in_terminal2240 = new BitSet(new long[]{0x0000006000000002L,0x0000000001000000L});
+ public static final BitSet FOLLOW_elementOptions_in_terminal2243 = new BitSet(new long[]{0x0000006000000002L});
+ public static final BitSet FOLLOW_STRING_LITERAL_in_terminal2264 = new BitSet(new long[]{0x0000006000000002L,0x0000000001000000L});
+ public static final BitSet FOLLOW_elementOptions_in_terminal2266 = new BitSet(new long[]{0x0000006000000002L});
+ public static final BitSet FOLLOW_90_in_terminal2287 = new BitSet(new long[]{0x0000006000000002L,0x0000000001000000L});
+ public static final BitSet FOLLOW_elementOptions_in_terminal2289 = new BitSet(new long[]{0x0000006000000002L});
+ public static final BitSet FOLLOW_ROOT_in_terminal2316 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_BANG_in_terminal2337 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_block_in_ebnf2380 = new BitSet(new long[]{0x0000000000000002L,0x0000000018400400L});
+ public static final BitSet FOLLOW_91_in_ebnf2388 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_74_in_ebnf2405 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_92_in_ebnf2422 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_86_in_ebnf2439 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_91_in_ebnfSuffix2524 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_74_in_ebnfSuffix2536 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_92_in_ebnfSuffix2549 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_REWRITE_in_rewrite2578 = new BitSet(new long[]{0x0000000080000000L});
+ public static final BitSet FOLLOW_SEMPRED_in_rewrite2582 = new BitSet(new long[]{0x0008F09000000000L,0x0000000020020000L});
+ public static final BitSet FOLLOW_rewrite_alternative_in_rewrite2586 = new BitSet(new long[]{0x0000008000000000L});
+ public static final BitSet FOLLOW_REWRITE_in_rewrite2594 = new BitSet(new long[]{0x0008F01000000000L,0x0000000020020000L});
+ public static final BitSet FOLLOW_rewrite_alternative_in_rewrite2598 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rewrite_template_in_rewrite_alternative2649 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rewrite_tree_alternative_in_rewrite_alternative2654 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_81_in_rewrite_tree_block2696 = new BitSet(new long[]{0x0008F01000000000L,0x0000000020020000L});
+ public static final BitSet FOLLOW_rewrite_tree_alternative_in_rewrite_tree_block2698 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
+ public static final BitSet FOLLOW_83_in_rewrite_tree_block2700 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rewrite_tree_element_in_rewrite_tree_alternative2734 = new BitSet(new long[]{0x0008F01000000002L,0x0000000020020000L});
+ public static final BitSet FOLLOW_rewrite_tree_atom_in_rewrite_tree_element2762 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rewrite_tree_atom_in_rewrite_tree_element2767 = new BitSet(new long[]{0x0000000000000000L,0x0000000018000400L});
+ public static final BitSet FOLLOW_ebnfSuffix_in_rewrite_tree_element2769 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rewrite_tree_in_rewrite_tree_element2803 = new BitSet(new long[]{0x0000000000000002L,0x0000000018000400L});
+ public static final BitSet FOLLOW_ebnfSuffix_in_rewrite_tree_element2809 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rewrite_tree_ebnf_in_rewrite_tree_element2855 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_CHAR_LITERAL_in_rewrite_tree_atom2871 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_TOKEN_REF_in_rewrite_tree_atom2878 = new BitSet(new long[]{0x0004000000000002L});
+ public static final BitSet FOLLOW_ARG_ACTION_in_rewrite_tree_atom2880 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_REF_in_rewrite_tree_atom2901 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_STRING_LITERAL_in_rewrite_tree_atom2908 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_93_in_rewrite_tree_atom2917 = new BitSet(new long[]{0x0008100000000000L});
+ public static final BitSet FOLLOW_id_in_rewrite_tree_atom2919 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ACTION_in_rewrite_tree_atom2930 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rewrite_tree_block_in_rewrite_tree_ebnf2951 = new BitSet(new long[]{0x0000000000000000L,0x0000000018000400L});
+ public static final BitSet FOLLOW_ebnfSuffix_in_rewrite_tree_ebnf2953 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_TREE_BEGIN_in_rewrite_tree2973 = new BitSet(new long[]{0x0008F00000000000L,0x0000000020000000L});
+ public static final BitSet FOLLOW_rewrite_tree_atom_in_rewrite_tree2975 = new BitSet(new long[]{0x0008F01000000000L,0x00000000200A0000L});
+ public static final BitSet FOLLOW_rewrite_tree_element_in_rewrite_tree2977 = new BitSet(new long[]{0x0008F01000000000L,0x00000000200A0000L});
+ public static final BitSet FOLLOW_83_in_rewrite_tree2980 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_id_in_rewrite_template3012 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L});
+ public static final BitSet FOLLOW_81_in_rewrite_template3016 = new BitSet(new long[]{0x0008100000000000L,0x0000000000080000L});
+ public static final BitSet FOLLOW_rewrite_template_args_in_rewrite_template3018 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
+ public static final BitSet FOLLOW_83_in_rewrite_template3020 = new BitSet(new long[]{0x0030000000000000L});
+ public static final BitSet FOLLOW_DOUBLE_QUOTE_STRING_LITERAL_in_rewrite_template3028 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_DOUBLE_ANGLE_STRING_LITERAL_in_rewrite_template3034 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rewrite_template_ref_in_rewrite_template3061 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rewrite_indirect_template_head_in_rewrite_template3070 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ACTION_in_rewrite_template3079 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_id_in_rewrite_template_ref3092 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L});
+ public static final BitSet FOLLOW_81_in_rewrite_template_ref3096 = new BitSet(new long[]{0x0008100000000000L,0x0000000000080000L});
+ public static final BitSet FOLLOW_rewrite_template_args_in_rewrite_template_ref3098 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
+ public static final BitSet FOLLOW_83_in_rewrite_template_ref3100 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_81_in_rewrite_indirect_template_head3128 = new BitSet(new long[]{0x0000800000000000L});
+ public static final BitSet FOLLOW_ACTION_in_rewrite_indirect_template_head3130 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
+ public static final BitSet FOLLOW_83_in_rewrite_indirect_template_head3132 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L});
+ public static final BitSet FOLLOW_81_in_rewrite_indirect_template_head3134 = new BitSet(new long[]{0x0008100000000000L,0x0000000000080000L});
+ public static final BitSet FOLLOW_rewrite_template_args_in_rewrite_indirect_template_head3136 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
+ public static final BitSet FOLLOW_83_in_rewrite_indirect_template_head3138 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rewrite_template_arg_in_rewrite_template_args3162 = new BitSet(new long[]{0x0000000000000002L,0x0000000000010000L});
+ public static final BitSet FOLLOW_80_in_rewrite_template_args3165 = new BitSet(new long[]{0x0008100000000000L});
+ public static final BitSet FOLLOW_rewrite_template_arg_in_rewrite_template_args3167 = new BitSet(new long[]{0x0000000000000002L,0x0000000000010000L});
+ public static final BitSet FOLLOW_id_in_rewrite_template_arg3200 = new BitSet(new long[]{0x0000020000000000L});
+ public static final BitSet FOLLOW_LABEL_ASSIGN_in_rewrite_template_arg3202 = new BitSet(new long[]{0x0000800000000000L});
+ public static final BitSet FOLLOW_ACTION_in_rewrite_template_arg3204 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_id_in_qid3225 = new BitSet(new long[]{0x0000000000000002L,0x0000000004000000L});
+ public static final BitSet FOLLOW_90_in_qid3228 = new BitSet(new long[]{0x0008100000000000L});
+ public static final BitSet FOLLOW_id_in_qid3230 = new BitSet(new long[]{0x0000000000000002L,0x0000000004000000L});
+ public static final BitSet FOLLOW_TOKEN_REF_in_id3242 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_REF_in_id3252 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rewrite_template_in_synpred1_ANTLRv32649 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rewrite_tree_alternative_in_synpred2_ANTLRv32654 = new BitSet(new long[]{0x0000000000000002L});
+
+}
\ No newline at end of file
diff --git a/debian/generated-sources/antlr3/org/antlr/grammar/v3/ANTLRv3Tree.java b/debian/generated-sources/antlr3/org/antlr/grammar/v3/ANTLRv3Tree.java
new file mode 100644
index 0000000..11481e0
--- /dev/null
+++ b/debian/generated-sources/antlr3/org/antlr/grammar/v3/ANTLRv3Tree.java
@@ -0,0 +1,3773 @@
+// $ANTLR 3.1.3 Mar 17, 2009 19:23:44 org/antlr/grammar/v3/ANTLRv3Tree.g 2010-05-13 00:10:15
+
+package org.antlr.grammar.v3;
+
+
+import org.antlr.runtime.*;
+import org.antlr.runtime.tree.*;import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+
+/** ANTLR v3 tree grammar to walk trees created by ANTLRv3.g */
+public class ANTLRv3Tree extends TreeParser {
+ public static final String[] tokenNames = new String[] {
+ "<invalid>", "<EOR>", "<DOWN>", "<UP>", "DOC_COMMENT", "PARSER", "LEXER", "RULE", "BLOCK", "OPTIONAL", "CLOSURE", "POSITIVE_CLOSURE", "SYNPRED", "RANGE", "CHAR_RANGE", "EPSILON", "ALT", "EOR", "EOB", "EOA", "ID", "ARG", "ARGLIST", "RET", "LEXER_GRAMMAR", "PARSER_GRAMMAR", "TREE_GRAMMAR", "COMBINED_GRAMMAR", "LABEL", "TEMPLATE", "SCOPE", "SEMPRED", "GATED_SEMPRED", "SYN_SEMPRED", "BACKTRACK_SEMPRED", "FRAGMENT", "TREE_BEGIN", "ROOT", "BANG", "REWRITE", "AT", "LABEL_ASSIGN", "LIST_ [...]
+ };
+ public static final int BACKTRACK_SEMPRED=34;
+ public static final int DOUBLE_ANGLE_STRING_LITERAL=53;
+ public static final int LEXER_GRAMMAR=24;
+ public static final int EOA=19;
+ public static final int ARGLIST=22;
+ public static final int EOF=-1;
+ public static final int SEMPRED=31;
+ public static final int ACTION=47;
+ public static final int EOB=18;
+ public static final int TOKEN_REF=44;
+ public static final int T__93=93;
+ public static final int T__91=91;
+ public static final int RET=23;
+ public static final int T__92=92;
+ public static final int STRING_LITERAL=45;
+ public static final int T__90=90;
+ public static final int ARG=21;
+ public static final int EOR=17;
+ public static final int ARG_ACTION=50;
+ public static final int DOUBLE_QUOTE_STRING_LITERAL=52;
+ public static final int NESTED_ARG_ACTION=60;
+ public static final int ACTION_CHAR_LITERAL=62;
+ public static final int T__80=80;
+ public static final int T__81=81;
+ public static final int T__82=82;
+ public static final int RULE=7;
+ public static final int ACTION_ESC=64;
+ public static final int T__83=83;
+ public static final int PARSER_GRAMMAR=25;
+ public static final int SRC=54;
+ public static final int INT=49;
+ public static final int CHAR_RANGE=14;
+ public static final int EPSILON=15;
+ public static final int T__85=85;
+ public static final int T__84=84;
+ public static final int T__87=87;
+ public static final int T__86=86;
+ public static final int REWRITE=39;
+ public static final int T__89=89;
+ public static final int T__88=88;
+ public static final int WS=66;
+ public static final int T__71=71;
+ public static final int T__72=72;
+ public static final int COMBINED_GRAMMAR=27;
+ public static final int T__70=70;
+ public static final int LEXER=6;
+ public static final int SL_COMMENT=55;
+ public static final int TREE_GRAMMAR=26;
+ public static final int T__76=76;
+ public static final int CLOSURE=10;
+ public static final int T__75=75;
+ public static final int PARSER=5;
+ public static final int T__74=74;
+ public static final int T__73=73;
+ public static final int T__79=79;
+ public static final int T__78=78;
+ public static final int T__77=77;
+ public static final int T__68=68;
+ public static final int T__69=69;
+ public static final int T__67=67;
+ public static final int NESTED_ACTION=63;
+ public static final int ESC=58;
+ public static final int FRAGMENT=35;
+ public static final int ID=20;
+ public static final int TREE_BEGIN=36;
+ public static final int AT=40;
+ public static final int ML_COMMENT=56;
+ public static final int ALT=16;
+ public static final int SCOPE=30;
+ public static final int LABEL_ASSIGN=41;
+ public static final int DOC_COMMENT=4;
+ public static final int WS_LOOP=65;
+ public static final int RANGE=13;
+ public static final int TOKENS=43;
+ public static final int GATED_SEMPRED=32;
+ public static final int LITERAL_CHAR=57;
+ public static final int BANG=38;
+ public static final int LIST_LABEL_ASSIGN=42;
+ public static final int ACTION_STRING_LITERAL=61;
+ public static final int ROOT=37;
+ public static final int RULE_REF=51;
+ public static final int SYNPRED=12;
+ public static final int OPTIONAL=9;
+ public static final int CHAR_LITERAL=46;
+ public static final int LABEL=28;
+ public static final int TEMPLATE=29;
+ public static final int SYN_SEMPRED=33;
+ public static final int XDIGIT=59;
+ public static final int BLOCK=8;
+ public static final int POSITIVE_CLOSURE=11;
+ public static final int OPTIONS=48;
+
+ // delegates
+ // delegators
+
+
+ public ANTLRv3Tree(TreeNodeStream input) {
+ this(input, new RecognizerSharedState());
+ }
+ public ANTLRv3Tree(TreeNodeStream input, RecognizerSharedState state) {
+ super(input, state);
+
+ }
+
+
+ public String[] getTokenNames() { return ANTLRv3Tree.tokenNames; }
+ public String getGrammarFileName() { return "org/antlr/grammar/v3/ANTLRv3Tree.g"; }
+
+
+
+ // $ANTLR start "grammarDef"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:41:1: grammarDef : ^( grammarType ID ( DOC_COMMENT )? ( optionsSpec )? ( tokensSpec )? ( attrScope )* ( action )* ( rule )+ ) ;
+ public final void grammarDef() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:42:5: ( ^( grammarType ID ( DOC_COMMENT )? ( optionsSpec )? ( tokensSpec )? ( attrScope )* ( action )* ( rule )+ ) )
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:42:9: ^( grammarType ID ( DOC_COMMENT )? ( optionsSpec )? ( tokensSpec )? ( attrScope )* ( action )* ( rule )+ )
+ {
+ pushFollow(FOLLOW_grammarType_in_grammarDef52);
+ grammarType();
+
+ state._fsp--;
+
+
+ match(input, Token.DOWN, null);
+ match(input,ID,FOLLOW_ID_in_grammarDef54);
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:42:27: ( DOC_COMMENT )?
+ int alt1=2;
+ int LA1_0 = input.LA(1);
+
+ if ( (LA1_0==DOC_COMMENT) ) {
+ alt1=1;
+ }
+ switch (alt1) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:42:27: DOC_COMMENT
+ {
+ match(input,DOC_COMMENT,FOLLOW_DOC_COMMENT_in_grammarDef56);
+
+ }
+ break;
+
+ }
+
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:42:40: ( optionsSpec )?
+ int alt2=2;
+ int LA2_0 = input.LA(1);
+
+ if ( (LA2_0==OPTIONS) ) {
+ alt2=1;
+ }
+ switch (alt2) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:42:40: optionsSpec
+ {
+ pushFollow(FOLLOW_optionsSpec_in_grammarDef59);
+ optionsSpec();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ }
+
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:42:53: ( tokensSpec )?
+ int alt3=2;
+ int LA3_0 = input.LA(1);
+
+ if ( (LA3_0==TOKENS) ) {
+ alt3=1;
+ }
+ switch (alt3) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:42:53: tokensSpec
+ {
+ pushFollow(FOLLOW_tokensSpec_in_grammarDef62);
+ tokensSpec();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ }
+
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:42:65: ( attrScope )*
+ loop4:
+ do {
+ int alt4=2;
+ int LA4_0 = input.LA(1);
+
+ if ( (LA4_0==SCOPE) ) {
+ alt4=1;
+ }
+
+
+ switch (alt4) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:42:65: attrScope
+ {
+ pushFollow(FOLLOW_attrScope_in_grammarDef65);
+ attrScope();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ default :
+ break loop4;
+ }
+ } while (true);
+
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:42:76: ( action )*
+ loop5:
+ do {
+ int alt5=2;
+ int LA5_0 = input.LA(1);
+
+ if ( (LA5_0==AT) ) {
+ alt5=1;
+ }
+
+
+ switch (alt5) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:42:76: action
+ {
+ pushFollow(FOLLOW_action_in_grammarDef68);
+ action();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ default :
+ break loop5;
+ }
+ } while (true);
+
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:42:84: ( rule )+
+ int cnt6=0;
+ loop6:
+ do {
+ int alt6=2;
+ int LA6_0 = input.LA(1);
+
+ if ( (LA6_0==RULE) ) {
+ alt6=1;
+ }
+
+
+ switch (alt6) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:42:84: rule
+ {
+ pushFollow(FOLLOW_rule_in_grammarDef71);
+ rule();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ default :
+ if ( cnt6 >= 1 ) break loop6;
+ EarlyExitException eee =
+ new EarlyExitException(6, input);
+ throw eee;
+ }
+ cnt6++;
+ } while (true);
+
+
+ match(input, Token.UP, null);
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "grammarDef"
+
+
+ // $ANTLR start "grammarType"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:45:1: grammarType : ( LEXER_GRAMMAR | PARSER_GRAMMAR | TREE_GRAMMAR | COMBINED_GRAMMAR );
+ public final void grammarType() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:46:2: ( LEXER_GRAMMAR | PARSER_GRAMMAR | TREE_GRAMMAR | COMBINED_GRAMMAR )
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:
+ {
+ if ( (input.LA(1)>=LEXER_GRAMMAR && input.LA(1)<=COMBINED_GRAMMAR) ) {
+ input.consume();
+ state.errorRecovery=false;
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ throw mse;
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "grammarType"
+
+
+ // $ANTLR start "tokensSpec"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:52:1: tokensSpec : ^( TOKENS ( tokenSpec )+ ) ;
+ public final void tokensSpec() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:53:2: ( ^( TOKENS ( tokenSpec )+ ) )
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:53:4: ^( TOKENS ( tokenSpec )+ )
+ {
+ match(input,TOKENS,FOLLOW_TOKENS_in_tokensSpec127);
+
+ match(input, Token.DOWN, null);
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:53:13: ( tokenSpec )+
+ int cnt7=0;
+ loop7:
+ do {
+ int alt7=2;
+ int LA7_0 = input.LA(1);
+
+ if ( (LA7_0==LABEL_ASSIGN||LA7_0==TOKEN_REF) ) {
+ alt7=1;
+ }
+
+
+ switch (alt7) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:53:13: tokenSpec
+ {
+ pushFollow(FOLLOW_tokenSpec_in_tokensSpec129);
+ tokenSpec();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ default :
+ if ( cnt7 >= 1 ) break loop7;
+ EarlyExitException eee =
+ new EarlyExitException(7, input);
+ throw eee;
+ }
+ cnt7++;
+ } while (true);
+
+
+ match(input, Token.UP, null);
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "tokensSpec"
+
+
+ // $ANTLR start "tokenSpec"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:56:1: tokenSpec : ( ^( '=' TOKEN_REF STRING_LITERAL ) | ^( '=' TOKEN_REF CHAR_LITERAL ) | TOKEN_REF );
+ public final void tokenSpec() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:57:2: ( ^( '=' TOKEN_REF STRING_LITERAL ) | ^( '=' TOKEN_REF CHAR_LITERAL ) | TOKEN_REF )
+ int alt8=3;
+ int LA8_0 = input.LA(1);
+
+ if ( (LA8_0==LABEL_ASSIGN) ) {
+ int LA8_1 = input.LA(2);
+
+ if ( (LA8_1==DOWN) ) {
+ int LA8_3 = input.LA(3);
+
+ if ( (LA8_3==TOKEN_REF) ) {
+ int LA8_4 = input.LA(4);
+
+ if ( (LA8_4==STRING_LITERAL) ) {
+ alt8=1;
+ }
+ else if ( (LA8_4==CHAR_LITERAL) ) {
+ alt8=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 8, 4, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 8, 3, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 8, 1, input);
+
+ throw nvae;
+ }
+ }
+ else if ( (LA8_0==TOKEN_REF) ) {
+ alt8=3;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 8, 0, input);
+
+ throw nvae;
+ }
+ switch (alt8) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:57:4: ^( '=' TOKEN_REF STRING_LITERAL )
+ {
+ match(input,LABEL_ASSIGN,FOLLOW_LABEL_ASSIGN_in_tokenSpec143);
+
+ match(input, Token.DOWN, null);
+ match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_tokenSpec145);
+ match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_tokenSpec147);
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:58:4: ^( '=' TOKEN_REF CHAR_LITERAL )
+ {
+ match(input,LABEL_ASSIGN,FOLLOW_LABEL_ASSIGN_in_tokenSpec154);
+
+ match(input, Token.DOWN, null);
+ match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_tokenSpec156);
+ match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_tokenSpec158);
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:59:4: TOKEN_REF
+ {
+ match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_tokenSpec164);
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "tokenSpec"
+
+
+ // $ANTLR start "attrScope"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:62:1: attrScope : ^( 'scope' ID ACTION ) ;
+ public final void attrScope() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:63:2: ( ^( 'scope' ID ACTION ) )
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:63:4: ^( 'scope' ID ACTION )
+ {
+ match(input,SCOPE,FOLLOW_SCOPE_in_attrScope176);
+
+ match(input, Token.DOWN, null);
+ match(input,ID,FOLLOW_ID_in_attrScope178);
+ match(input,ACTION,FOLLOW_ACTION_in_attrScope180);
+
+ match(input, Token.UP, null);
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "attrScope"
+
+
+ // $ANTLR start "action"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:66:1: action : ( ^( '@' ID ID ACTION ) | ^( '@' ID ACTION ) );
+ public final void action() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:67:2: ( ^( '@' ID ID ACTION ) | ^( '@' ID ACTION ) )
+ int alt9=2;
+ int LA9_0 = input.LA(1);
+
+ if ( (LA9_0==AT) ) {
+ int LA9_1 = input.LA(2);
+
+ if ( (LA9_1==DOWN) ) {
+ int LA9_2 = input.LA(3);
+
+ if ( (LA9_2==ID) ) {
+ int LA9_3 = input.LA(4);
+
+ if ( (LA9_3==ID) ) {
+ alt9=1;
+ }
+ else if ( (LA9_3==ACTION) ) {
+ alt9=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 9, 3, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 9, 2, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 9, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 9, 0, input);
+
+ throw nvae;
+ }
+ switch (alt9) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:67:4: ^( '@' ID ID ACTION )
+ {
+ match(input,AT,FOLLOW_AT_in_action193);
+
+ match(input, Token.DOWN, null);
+ match(input,ID,FOLLOW_ID_in_action195);
+ match(input,ID,FOLLOW_ID_in_action197);
+ match(input,ACTION,FOLLOW_ACTION_in_action199);
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:68:4: ^( '@' ID ACTION )
+ {
+ match(input,AT,FOLLOW_AT_in_action206);
+
+ match(input, Token.DOWN, null);
+ match(input,ID,FOLLOW_ID_in_action208);
+ match(input,ACTION,FOLLOW_ACTION_in_action210);
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "action"
+
+
+ // $ANTLR start "optionsSpec"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:71:1: optionsSpec : ^( OPTIONS ( option )+ ) ;
+ public final void optionsSpec() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:72:2: ( ^( OPTIONS ( option )+ ) )
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:72:4: ^( OPTIONS ( option )+ )
+ {
+ match(input,OPTIONS,FOLLOW_OPTIONS_in_optionsSpec223);
+
+ match(input, Token.DOWN, null);
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:72:14: ( option )+
+ int cnt10=0;
+ loop10:
+ do {
+ int alt10=2;
+ int LA10_0 = input.LA(1);
+
+ if ( (LA10_0==ID||LA10_0==LABEL_ASSIGN) ) {
+ alt10=1;
+ }
+
+
+ switch (alt10) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:72:14: option
+ {
+ pushFollow(FOLLOW_option_in_optionsSpec225);
+ option();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ default :
+ if ( cnt10 >= 1 ) break loop10;
+ EarlyExitException eee =
+ new EarlyExitException(10, input);
+ throw eee;
+ }
+ cnt10++;
+ } while (true);
+
+
+ match(input, Token.UP, null);
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "optionsSpec"
+
+
+ // $ANTLR start "option"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:75:1: option : ( qid | ^( '=' ID optionValue ) );
+ public final void option() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:76:5: ( qid | ^( '=' ID optionValue ) )
+ int alt11=2;
+ int LA11_0 = input.LA(1);
+
+ if ( (LA11_0==ID) ) {
+ alt11=1;
+ }
+ else if ( (LA11_0==LABEL_ASSIGN) ) {
+ alt11=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 11, 0, input);
+
+ throw nvae;
+ }
+ switch (alt11) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:76:9: qid
+ {
+ pushFollow(FOLLOW_qid_in_option243);
+ qid();
+
+ state._fsp--;
+
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:77:7: ^( '=' ID optionValue )
+ {
+ match(input,LABEL_ASSIGN,FOLLOW_LABEL_ASSIGN_in_option253);
+
+ match(input, Token.DOWN, null);
+ match(input,ID,FOLLOW_ID_in_option255);
+ pushFollow(FOLLOW_optionValue_in_option257);
+ optionValue();
+
+ state._fsp--;
+
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "option"
+
+
+ // $ANTLR start "optionValue"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:80:1: optionValue : ( ID | STRING_LITERAL | CHAR_LITERAL | INT );
+ public final void optionValue() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:81:5: ( ID | STRING_LITERAL | CHAR_LITERAL | INT )
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:
+ {
+ if ( input.LA(1)==ID||(input.LA(1)>=STRING_LITERAL && input.LA(1)<=CHAR_LITERAL)||input.LA(1)==INT ) {
+ input.consume();
+ state.errorRecovery=false;
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ throw mse;
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "optionValue"
+
+
+ // $ANTLR start "rule"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:87:1: rule : ^( RULE ID ( modifier )? ( ^( ARG ARG_ACTION ) )? ( ^( RET ARG_ACTION ) )? ( throwsSpec )? ( optionsSpec )? ( ruleScopeSpec )? ( ruleAction )* altList ( exceptionGroup )? EOR ) ;
+ public final void rule() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:88:2: ( ^( RULE ID ( modifier )? ( ^( ARG ARG_ACTION ) )? ( ^( RET ARG_ACTION ) )? ( throwsSpec )? ( optionsSpec )? ( ruleScopeSpec )? ( ruleAction )* altList ( exceptionGroup )? EOR ) )
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:88:4: ^( RULE ID ( modifier )? ( ^( ARG ARG_ACTION ) )? ( ^( RET ARG_ACTION ) )? ( throwsSpec )? ( optionsSpec )? ( ruleScopeSpec )? ( ruleAction )* altList ( exceptionGroup )? EOR )
+ {
+ match(input,RULE,FOLLOW_RULE_in_rule323);
+
+ match(input, Token.DOWN, null);
+ match(input,ID,FOLLOW_ID_in_rule325);
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:88:15: ( modifier )?
+ int alt12=2;
+ int LA12_0 = input.LA(1);
+
+ if ( (LA12_0==FRAGMENT||(LA12_0>=75 && LA12_0<=77)) ) {
+ alt12=1;
+ }
+ switch (alt12) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:88:15: modifier
+ {
+ pushFollow(FOLLOW_modifier_in_rule327);
+ modifier();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ }
+
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:88:25: ( ^( ARG ARG_ACTION ) )?
+ int alt13=2;
+ int LA13_0 = input.LA(1);
+
+ if ( (LA13_0==ARG) ) {
+ alt13=1;
+ }
+ switch (alt13) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:88:26: ^( ARG ARG_ACTION )
+ {
+ match(input,ARG,FOLLOW_ARG_in_rule332);
+
+ match(input, Token.DOWN, null);
+ match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_rule334);
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+
+ }
+
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:88:46: ( ^( RET ARG_ACTION ) )?
+ int alt14=2;
+ int LA14_0 = input.LA(1);
+
+ if ( (LA14_0==RET) ) {
+ alt14=1;
+ }
+ switch (alt14) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:88:47: ^( RET ARG_ACTION )
+ {
+ match(input,RET,FOLLOW_RET_in_rule341);
+
+ match(input, Token.DOWN, null);
+ match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_rule343);
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+
+ }
+
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:89:9: ( throwsSpec )?
+ int alt15=2;
+ int LA15_0 = input.LA(1);
+
+ if ( (LA15_0==79) ) {
+ alt15=1;
+ }
+ switch (alt15) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:89:9: throwsSpec
+ {
+ pushFollow(FOLLOW_throwsSpec_in_rule356);
+ throwsSpec();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ }
+
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:89:21: ( optionsSpec )?
+ int alt16=2;
+ int LA16_0 = input.LA(1);
+
+ if ( (LA16_0==OPTIONS) ) {
+ alt16=1;
+ }
+ switch (alt16) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:89:21: optionsSpec
+ {
+ pushFollow(FOLLOW_optionsSpec_in_rule359);
+ optionsSpec();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ }
+
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:89:34: ( ruleScopeSpec )?
+ int alt17=2;
+ int LA17_0 = input.LA(1);
+
+ if ( (LA17_0==SCOPE) ) {
+ alt17=1;
+ }
+ switch (alt17) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:89:34: ruleScopeSpec
+ {
+ pushFollow(FOLLOW_ruleScopeSpec_in_rule362);
+ ruleScopeSpec();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ }
+
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:89:49: ( ruleAction )*
+ loop18:
+ do {
+ int alt18=2;
+ int LA18_0 = input.LA(1);
+
+ if ( (LA18_0==AT) ) {
+ alt18=1;
+ }
+
+
+ switch (alt18) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:89:49: ruleAction
+ {
+ pushFollow(FOLLOW_ruleAction_in_rule365);
+ ruleAction();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ default :
+ break loop18;
+ }
+ } while (true);
+
+ pushFollow(FOLLOW_altList_in_rule376);
+ altList();
+
+ state._fsp--;
+
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:91:9: ( exceptionGroup )?
+ int alt19=2;
+ int LA19_0 = input.LA(1);
+
+ if ( ((LA19_0>=84 && LA19_0<=85)) ) {
+ alt19=1;
+ }
+ switch (alt19) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:91:9: exceptionGroup
+ {
+ pushFollow(FOLLOW_exceptionGroup_in_rule386);
+ exceptionGroup();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ }
+
+ match(input,EOR,FOLLOW_EOR_in_rule389);
+
+ match(input, Token.UP, null);
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "rule"
+
+
+ // $ANTLR start "modifier"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:95:1: modifier : ( 'protected' | 'public' | 'private' | 'fragment' );
+ public final void modifier() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:96:2: ( 'protected' | 'public' | 'private' | 'fragment' )
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:
+ {
+ if ( input.LA(1)==FRAGMENT||(input.LA(1)>=75 && input.LA(1)<=77) ) {
+ input.consume();
+ state.errorRecovery=false;
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ throw mse;
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "modifier"
+
+
+ // $ANTLR start "ruleAction"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:99:1: ruleAction : ^( '@' ID ACTION ) ;
+ public final void ruleAction() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:101:2: ( ^( '@' ID ACTION ) )
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:101:4: ^( '@' ID ACTION )
+ {
+ match(input,AT,FOLLOW_AT_in_ruleAction428);
+
+ match(input, Token.DOWN, null);
+ match(input,ID,FOLLOW_ID_in_ruleAction430);
+ match(input,ACTION,FOLLOW_ACTION_in_ruleAction432);
+
+ match(input, Token.UP, null);
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "ruleAction"
+
+
+ // $ANTLR start "throwsSpec"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:104:1: throwsSpec : ^( 'throws' ( ID )+ ) ;
+ public final void throwsSpec() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:105:2: ( ^( 'throws' ( ID )+ ) )
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:105:4: ^( 'throws' ( ID )+ )
+ {
+ match(input,79,FOLLOW_79_in_throwsSpec445);
+
+ match(input, Token.DOWN, null);
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:105:15: ( ID )+
+ int cnt20=0;
+ loop20:
+ do {
+ int alt20=2;
+ int LA20_0 = input.LA(1);
+
+ if ( (LA20_0==ID) ) {
+ alt20=1;
+ }
+
+
+ switch (alt20) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:105:15: ID
+ {
+ match(input,ID,FOLLOW_ID_in_throwsSpec447);
+
+ }
+ break;
+
+ default :
+ if ( cnt20 >= 1 ) break loop20;
+ EarlyExitException eee =
+ new EarlyExitException(20, input);
+ throw eee;
+ }
+ cnt20++;
+ } while (true);
+
+
+ match(input, Token.UP, null);
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "throwsSpec"
+
+
+ // $ANTLR start "ruleScopeSpec"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:108:1: ruleScopeSpec : ( ^( 'scope' ACTION ) | ^( 'scope' ACTION ( ID )+ ) | ^( 'scope' ( ID )+ ) );
+ public final void ruleScopeSpec() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:109:2: ( ^( 'scope' ACTION ) | ^( 'scope' ACTION ( ID )+ ) | ^( 'scope' ( ID )+ ) )
+ int alt23=3;
+ int LA23_0 = input.LA(1);
+
+ if ( (LA23_0==SCOPE) ) {
+ int LA23_1 = input.LA(2);
+
+ if ( (LA23_1==DOWN) ) {
+ int LA23_2 = input.LA(3);
+
+ if ( (LA23_2==ACTION) ) {
+ int LA23_3 = input.LA(4);
+
+ if ( (LA23_3==UP) ) {
+ alt23=1;
+ }
+ else if ( (LA23_3==ID) ) {
+ alt23=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 23, 3, input);
+
+ throw nvae;
+ }
+ }
+ else if ( (LA23_2==ID) ) {
+ alt23=3;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 23, 2, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 23, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 23, 0, input);
+
+ throw nvae;
+ }
+ switch (alt23) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:109:4: ^( 'scope' ACTION )
+ {
+ match(input,SCOPE,FOLLOW_SCOPE_in_ruleScopeSpec461);
+
+ match(input, Token.DOWN, null);
+ match(input,ACTION,FOLLOW_ACTION_in_ruleScopeSpec463);
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:110:4: ^( 'scope' ACTION ( ID )+ )
+ {
+ match(input,SCOPE,FOLLOW_SCOPE_in_ruleScopeSpec470);
+
+ match(input, Token.DOWN, null);
+ match(input,ACTION,FOLLOW_ACTION_in_ruleScopeSpec472);
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:110:21: ( ID )+
+ int cnt21=0;
+ loop21:
+ do {
+ int alt21=2;
+ int LA21_0 = input.LA(1);
+
+ if ( (LA21_0==ID) ) {
+ alt21=1;
+ }
+
+
+ switch (alt21) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:110:21: ID
+ {
+ match(input,ID,FOLLOW_ID_in_ruleScopeSpec474);
+
+ }
+ break;
+
+ default :
+ if ( cnt21 >= 1 ) break loop21;
+ EarlyExitException eee =
+ new EarlyExitException(21, input);
+ throw eee;
+ }
+ cnt21++;
+ } while (true);
+
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:111:4: ^( 'scope' ( ID )+ )
+ {
+ match(input,SCOPE,FOLLOW_SCOPE_in_ruleScopeSpec482);
+
+ match(input, Token.DOWN, null);
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:111:14: ( ID )+
+ int cnt22=0;
+ loop22:
+ do {
+ int alt22=2;
+ int LA22_0 = input.LA(1);
+
+ if ( (LA22_0==ID) ) {
+ alt22=1;
+ }
+
+
+ switch (alt22) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:111:14: ID
+ {
+ match(input,ID,FOLLOW_ID_in_ruleScopeSpec484);
+
+ }
+ break;
+
+ default :
+ if ( cnt22 >= 1 ) break loop22;
+ EarlyExitException eee =
+ new EarlyExitException(22, input);
+ throw eee;
+ }
+ cnt22++;
+ } while (true);
+
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "ruleScopeSpec"
+
+
+ // $ANTLR start "block"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:114:1: block : ^( BLOCK ( optionsSpec )? ( alternative rewrite )+ EOB ) ;
+ public final void block() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:115:5: ( ^( BLOCK ( optionsSpec )? ( alternative rewrite )+ EOB ) )
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:115:9: ^( BLOCK ( optionsSpec )? ( alternative rewrite )+ EOB )
+ {
+ match(input,BLOCK,FOLLOW_BLOCK_in_block504);
+
+ match(input, Token.DOWN, null);
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:115:18: ( optionsSpec )?
+ int alt24=2;
+ int LA24_0 = input.LA(1);
+
+ if ( (LA24_0==OPTIONS) ) {
+ alt24=1;
+ }
+ switch (alt24) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:115:18: optionsSpec
+ {
+ pushFollow(FOLLOW_optionsSpec_in_block506);
+ optionsSpec();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ }
+
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:115:31: ( alternative rewrite )+
+ int cnt25=0;
+ loop25:
+ do {
+ int alt25=2;
+ int LA25_0 = input.LA(1);
+
+ if ( (LA25_0==ALT) ) {
+ alt25=1;
+ }
+
+
+ switch (alt25) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:115:32: alternative rewrite
+ {
+ pushFollow(FOLLOW_alternative_in_block510);
+ alternative();
+
+ state._fsp--;
+
+ pushFollow(FOLLOW_rewrite_in_block512);
+ rewrite();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ default :
+ if ( cnt25 >= 1 ) break loop25;
+ EarlyExitException eee =
+ new EarlyExitException(25, input);
+ throw eee;
+ }
+ cnt25++;
+ } while (true);
+
+ match(input,EOB,FOLLOW_EOB_in_block516);
+
+ match(input, Token.UP, null);
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "block"
+
+
+ // $ANTLR start "altList"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:118:1: altList : ^( BLOCK ( alternative rewrite )+ EOB ) ;
+ public final void altList() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:119:5: ( ^( BLOCK ( alternative rewrite )+ EOB ) )
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:119:9: ^( BLOCK ( alternative rewrite )+ EOB )
+ {
+ match(input,BLOCK,FOLLOW_BLOCK_in_altList539);
+
+ match(input, Token.DOWN, null);
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:119:18: ( alternative rewrite )+
+ int cnt26=0;
+ loop26:
+ do {
+ int alt26=2;
+ int LA26_0 = input.LA(1);
+
+ if ( (LA26_0==ALT) ) {
+ alt26=1;
+ }
+
+
+ switch (alt26) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:119:19: alternative rewrite
+ {
+ pushFollow(FOLLOW_alternative_in_altList542);
+ alternative();
+
+ state._fsp--;
+
+ pushFollow(FOLLOW_rewrite_in_altList544);
+ rewrite();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ default :
+ if ( cnt26 >= 1 ) break loop26;
+ EarlyExitException eee =
+ new EarlyExitException(26, input);
+ throw eee;
+ }
+ cnt26++;
+ } while (true);
+
+ match(input,EOB,FOLLOW_EOB_in_altList548);
+
+ match(input, Token.UP, null);
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "altList"
+
+
+ // $ANTLR start "alternative"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:122:1: alternative : ( ^( ALT ( element )+ EOA ) | ^( ALT EPSILON EOA ) );
+ public final void alternative() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:123:5: ( ^( ALT ( element )+ EOA ) | ^( ALT EPSILON EOA ) )
+ int alt28=2;
+ int LA28_0 = input.LA(1);
+
+ if ( (LA28_0==ALT) ) {
+ int LA28_1 = input.LA(2);
+
+ if ( (LA28_1==DOWN) ) {
+ int LA28_2 = input.LA(3);
+
+ if ( (LA28_2==EPSILON) ) {
+ alt28=2;
+ }
+ else if ( ((LA28_2>=BLOCK && LA28_2<=SYNPRED)||LA28_2==CHAR_RANGE||(LA28_2>=SEMPRED && LA28_2<=SYN_SEMPRED)||(LA28_2>=TREE_BEGIN && LA28_2<=BANG)||(LA28_2>=LABEL_ASSIGN && LA28_2<=LIST_LABEL_ASSIGN)||(LA28_2>=TOKEN_REF && LA28_2<=ACTION)||LA28_2==RULE_REF||LA28_2==87||LA28_2==90) ) {
+ alt28=1;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 28, 2, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 28, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 28, 0, input);
+
+ throw nvae;
+ }
+ switch (alt28) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:123:9: ^( ALT ( element )+ EOA )
+ {
+ match(input,ALT,FOLLOW_ALT_in_alternative570);
+
+ match(input, Token.DOWN, null);
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:123:15: ( element )+
+ int cnt27=0;
+ loop27:
+ do {
+ int alt27=2;
+ int LA27_0 = input.LA(1);
+
+ if ( ((LA27_0>=BLOCK && LA27_0<=SYNPRED)||LA27_0==CHAR_RANGE||(LA27_0>=SEMPRED && LA27_0<=SYN_SEMPRED)||(LA27_0>=TREE_BEGIN && LA27_0<=BANG)||(LA27_0>=LABEL_ASSIGN && LA27_0<=LIST_LABEL_ASSIGN)||(LA27_0>=TOKEN_REF && LA27_0<=ACTION)||LA27_0==RULE_REF||LA27_0==87||LA27_0==90) ) {
+ alt27=1;
+ }
+
+
+ switch (alt27) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:123:15: element
+ {
+ pushFollow(FOLLOW_element_in_alternative572);
+ element();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ default :
+ if ( cnt27 >= 1 ) break loop27;
+ EarlyExitException eee =
+ new EarlyExitException(27, input);
+ throw eee;
+ }
+ cnt27++;
+ } while (true);
+
+ match(input,EOA,FOLLOW_EOA_in_alternative575);
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:124:9: ^( ALT EPSILON EOA )
+ {
+ match(input,ALT,FOLLOW_ALT_in_alternative587);
+
+ match(input, Token.DOWN, null);
+ match(input,EPSILON,FOLLOW_EPSILON_in_alternative589);
+ match(input,EOA,FOLLOW_EOA_in_alternative591);
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "alternative"
+
+
+ // $ANTLR start "exceptionGroup"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:127:1: exceptionGroup : ( ( exceptionHandler )+ ( finallyClause )? | finallyClause );
+ public final void exceptionGroup() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:128:2: ( ( exceptionHandler )+ ( finallyClause )? | finallyClause )
+ int alt31=2;
+ int LA31_0 = input.LA(1);
+
+ if ( (LA31_0==84) ) {
+ alt31=1;
+ }
+ else if ( (LA31_0==85) ) {
+ alt31=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 31, 0, input);
+
+ throw nvae;
+ }
+ switch (alt31) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:128:4: ( exceptionHandler )+ ( finallyClause )?
+ {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:128:4: ( exceptionHandler )+
+ int cnt29=0;
+ loop29:
+ do {
+ int alt29=2;
+ int LA29_0 = input.LA(1);
+
+ if ( (LA29_0==84) ) {
+ alt29=1;
+ }
+
+
+ switch (alt29) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:128:4: exceptionHandler
+ {
+ pushFollow(FOLLOW_exceptionHandler_in_exceptionGroup606);
+ exceptionHandler();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ default :
+ if ( cnt29 >= 1 ) break loop29;
+ EarlyExitException eee =
+ new EarlyExitException(29, input);
+ throw eee;
+ }
+ cnt29++;
+ } while (true);
+
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:128:22: ( finallyClause )?
+ int alt30=2;
+ int LA30_0 = input.LA(1);
+
+ if ( (LA30_0==85) ) {
+ alt30=1;
+ }
+ switch (alt30) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:128:22: finallyClause
+ {
+ pushFollow(FOLLOW_finallyClause_in_exceptionGroup609);
+ finallyClause();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:129:4: finallyClause
+ {
+ pushFollow(FOLLOW_finallyClause_in_exceptionGroup615);
+ finallyClause();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "exceptionGroup"
+
+
+ // $ANTLR start "exceptionHandler"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:132:1: exceptionHandler : ^( 'catch' ARG_ACTION ACTION ) ;
+ public final void exceptionHandler() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:133:5: ( ^( 'catch' ARG_ACTION ACTION ) )
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:133:10: ^( 'catch' ARG_ACTION ACTION )
+ {
+ match(input,84,FOLLOW_84_in_exceptionHandler636);
+
+ match(input, Token.DOWN, null);
+ match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_exceptionHandler638);
+ match(input,ACTION,FOLLOW_ACTION_in_exceptionHandler640);
+
+ match(input, Token.UP, null);
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "exceptionHandler"
+
+
+ // $ANTLR start "finallyClause"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:136:1: finallyClause : ^( 'finally' ACTION ) ;
+ public final void finallyClause() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:137:5: ( ^( 'finally' ACTION ) )
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:137:10: ^( 'finally' ACTION )
+ {
+ match(input,85,FOLLOW_85_in_finallyClause662);
+
+ match(input, Token.DOWN, null);
+ match(input,ACTION,FOLLOW_ACTION_in_finallyClause664);
+
+ match(input, Token.UP, null);
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "finallyClause"
+
+
+ // $ANTLR start "element"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:140:1: element : ( ^( ( '=' | '+=' ) ID block ) | ^( ( '=' | '+=' ) ID atom ) | atom | ebnf | ACTION | SEMPRED | GATED_SEMPRED | ^( TREE_BEGIN ( element )+ ) );
+ public final void element() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:141:2: ( ^( ( '=' | '+=' ) ID block ) | ^( ( '=' | '+=' ) ID atom ) | atom | ebnf | ACTION | SEMPRED | GATED_SEMPRED | ^( TREE_BEGIN ( element )+ ) )
+ int alt33=8;
+ alt33 = dfa33.predict(input);
+ switch (alt33) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:141:4: ^( ( '=' | '+=' ) ID block )
+ {
+ if ( (input.LA(1)>=LABEL_ASSIGN && input.LA(1)<=LIST_LABEL_ASSIGN) ) {
+ input.consume();
+ state.errorRecovery=false;
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ throw mse;
+ }
+
+
+ match(input, Token.DOWN, null);
+ match(input,ID,FOLLOW_ID_in_element686);
+ pushFollow(FOLLOW_block_in_element688);
+ block();
+
+ state._fsp--;
+
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:142:4: ^( ( '=' | '+=' ) ID atom )
+ {
+ if ( (input.LA(1)>=LABEL_ASSIGN && input.LA(1)<=LIST_LABEL_ASSIGN) ) {
+ input.consume();
+ state.errorRecovery=false;
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ throw mse;
+ }
+
+
+ match(input, Token.DOWN, null);
+ match(input,ID,FOLLOW_ID_in_element701);
+ pushFollow(FOLLOW_atom_in_element703);
+ atom();
+
+ state._fsp--;
+
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:143:4: atom
+ {
+ pushFollow(FOLLOW_atom_in_element709);
+ atom();
+
+ state._fsp--;
+
+
+ }
+ break;
+ case 4 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:144:4: ebnf
+ {
+ pushFollow(FOLLOW_ebnf_in_element714);
+ ebnf();
+
+ state._fsp--;
+
+
+ }
+ break;
+ case 5 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:145:6: ACTION
+ {
+ match(input,ACTION,FOLLOW_ACTION_in_element721);
+
+ }
+ break;
+ case 6 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:146:6: SEMPRED
+ {
+ match(input,SEMPRED,FOLLOW_SEMPRED_in_element728);
+
+ }
+ break;
+ case 7 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:147:4: GATED_SEMPRED
+ {
+ match(input,GATED_SEMPRED,FOLLOW_GATED_SEMPRED_in_element733);
+
+ }
+ break;
+ case 8 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:148:6: ^( TREE_BEGIN ( element )+ )
+ {
+ match(input,TREE_BEGIN,FOLLOW_TREE_BEGIN_in_element741);
+
+ match(input, Token.DOWN, null);
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:148:19: ( element )+
+ int cnt32=0;
+ loop32:
+ do {
+ int alt32=2;
+ int LA32_0 = input.LA(1);
+
+ if ( ((LA32_0>=BLOCK && LA32_0<=SYNPRED)||LA32_0==CHAR_RANGE||(LA32_0>=SEMPRED && LA32_0<=SYN_SEMPRED)||(LA32_0>=TREE_BEGIN && LA32_0<=BANG)||(LA32_0>=LABEL_ASSIGN && LA32_0<=LIST_LABEL_ASSIGN)||(LA32_0>=TOKEN_REF && LA32_0<=ACTION)||LA32_0==RULE_REF||LA32_0==87||LA32_0==90) ) {
+ alt32=1;
+ }
+
+
+ switch (alt32) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:148:19: element
+ {
+ pushFollow(FOLLOW_element_in_element743);
+ element();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ default :
+ if ( cnt32 >= 1 ) break loop32;
+ EarlyExitException eee =
+ new EarlyExitException(32, input);
+ throw eee;
+ }
+ cnt32++;
+ } while (true);
+
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "element"
+
+
+ // $ANTLR start "atom"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:151:1: atom : ( ^( ( '^' | '!' ) atom ) | ^( CHAR_RANGE CHAR_LITERAL CHAR_LITERAL ( optionsSpec )? ) | ^( '~' notTerminal ( optionsSpec )? ) | ^( '~' block ( optionsSpec )? ) | ^( RULE_REF ARG_ACTION ) | RULE_REF | CHAR_LITERAL | ^( CHAR_LITERAL optionsSpec ) | TOKEN_REF | ^( TOKEN_REF optionsSpec ) | ^( TOKEN_REF ARG_ACTION optionsSpec ) | ^( TOKEN_REF ARG_ACTION ) | STRING_LITERAL | ^( STRING_LITERAL optionsSpec ) | '.' | ^( '.' ( optionsSpec )? ) );
+ public final void atom() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:151:5: ( ^( ( '^' | '!' ) atom ) | ^( CHAR_RANGE CHAR_LITERAL CHAR_LITERAL ( optionsSpec )? ) | ^( '~' notTerminal ( optionsSpec )? ) | ^( '~' block ( optionsSpec )? ) | ^( RULE_REF ARG_ACTION ) | RULE_REF | CHAR_LITERAL | ^( CHAR_LITERAL optionsSpec ) | TOKEN_REF | ^( TOKEN_REF optionsSpec ) | ^( TOKEN_REF ARG_ACTION optionsSpec ) | ^( TOKEN_REF ARG_ACTION ) | STRING_LITERAL | ^( STRING_LITERAL optionsSpec ) | '.' | ^( '.' ( optionsSpec )? ) )
+ int alt38=16;
+ alt38 = dfa38.predict(input);
+ switch (alt38) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:151:9: ^( ( '^' | '!' ) atom )
+ {
+ if ( (input.LA(1)>=ROOT && input.LA(1)<=BANG) ) {
+ input.consume();
+ state.errorRecovery=false;
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ throw mse;
+ }
+
+
+ match(input, Token.DOWN, null);
+ pushFollow(FOLLOW_atom_in_atom763);
+ atom();
+
+ state._fsp--;
+
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:152:4: ^( CHAR_RANGE CHAR_LITERAL CHAR_LITERAL ( optionsSpec )? )
+ {
+ match(input,CHAR_RANGE,FOLLOW_CHAR_RANGE_in_atom770);
+
+ match(input, Token.DOWN, null);
+ match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_atom772);
+ match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_atom774);
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:152:43: ( optionsSpec )?
+ int alt34=2;
+ int LA34_0 = input.LA(1);
+
+ if ( (LA34_0==OPTIONS) ) {
+ alt34=1;
+ }
+ switch (alt34) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:152:43: optionsSpec
+ {
+ pushFollow(FOLLOW_optionsSpec_in_atom776);
+ optionsSpec();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ }
+
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:153:4: ^( '~' notTerminal ( optionsSpec )? )
+ {
+ match(input,87,FOLLOW_87_in_atom784);
+
+ match(input, Token.DOWN, null);
+ pushFollow(FOLLOW_notTerminal_in_atom786);
+ notTerminal();
+
+ state._fsp--;
+
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:153:22: ( optionsSpec )?
+ int alt35=2;
+ int LA35_0 = input.LA(1);
+
+ if ( (LA35_0==OPTIONS) ) {
+ alt35=1;
+ }
+ switch (alt35) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:153:22: optionsSpec
+ {
+ pushFollow(FOLLOW_optionsSpec_in_atom788);
+ optionsSpec();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ }
+
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 4 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:154:4: ^( '~' block ( optionsSpec )? )
+ {
+ match(input,87,FOLLOW_87_in_atom796);
+
+ match(input, Token.DOWN, null);
+ pushFollow(FOLLOW_block_in_atom798);
+ block();
+
+ state._fsp--;
+
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:154:16: ( optionsSpec )?
+ int alt36=2;
+ int LA36_0 = input.LA(1);
+
+ if ( (LA36_0==OPTIONS) ) {
+ alt36=1;
+ }
+ switch (alt36) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:154:16: optionsSpec
+ {
+ pushFollow(FOLLOW_optionsSpec_in_atom800);
+ optionsSpec();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ }
+
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 5 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:155:7: ^( RULE_REF ARG_ACTION )
+ {
+ match(input,RULE_REF,FOLLOW_RULE_REF_in_atom811);
+
+ match(input, Token.DOWN, null);
+ match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_atom813);
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 6 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:156:7: RULE_REF
+ {
+ match(input,RULE_REF,FOLLOW_RULE_REF_in_atom822);
+
+ }
+ break;
+ case 7 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:157:9: CHAR_LITERAL
+ {
+ match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_atom832);
+
+ }
+ break;
+ case 8 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:158:9: ^( CHAR_LITERAL optionsSpec )
+ {
+ match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_atom843);
+
+ match(input, Token.DOWN, null);
+ pushFollow(FOLLOW_optionsSpec_in_atom845);
+ optionsSpec();
+
+ state._fsp--;
+
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 9 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:159:7: TOKEN_REF
+ {
+ match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_atom854);
+
+ }
+ break;
+ case 10 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:160:7: ^( TOKEN_REF optionsSpec )
+ {
+ match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_atom863);
+
+ match(input, Token.DOWN, null);
+ pushFollow(FOLLOW_optionsSpec_in_atom865);
+ optionsSpec();
+
+ state._fsp--;
+
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 11 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:161:7: ^( TOKEN_REF ARG_ACTION optionsSpec )
+ {
+ match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_atom875);
+
+ match(input, Token.DOWN, null);
+ match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_atom877);
+ pushFollow(FOLLOW_optionsSpec_in_atom879);
+ optionsSpec();
+
+ state._fsp--;
+
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 12 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:162:7: ^( TOKEN_REF ARG_ACTION )
+ {
+ match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_atom889);
+
+ match(input, Token.DOWN, null);
+ match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_atom891);
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 13 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:163:7: STRING_LITERAL
+ {
+ match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_atom900);
+
+ }
+ break;
+ case 14 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:164:7: ^( STRING_LITERAL optionsSpec )
+ {
+ match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_atom909);
+
+ match(input, Token.DOWN, null);
+ pushFollow(FOLLOW_optionsSpec_in_atom911);
+ optionsSpec();
+
+ state._fsp--;
+
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 15 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:165:7: '.'
+ {
+ match(input,90,FOLLOW_90_in_atom920);
+
+ }
+ break;
+ case 16 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:166:7: ^( '.' ( optionsSpec )? )
+ {
+ match(input,90,FOLLOW_90_in_atom929);
+
+ if ( input.LA(1)==Token.DOWN ) {
+ match(input, Token.DOWN, null);
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:166:13: ( optionsSpec )?
+ int alt37=2;
+ int LA37_0 = input.LA(1);
+
+ if ( (LA37_0==OPTIONS) ) {
+ alt37=1;
+ }
+ switch (alt37) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:166:13: optionsSpec
+ {
+ pushFollow(FOLLOW_optionsSpec_in_atom931);
+ optionsSpec();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ }
+
+
+ match(input, Token.UP, null);
+ }
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "atom"
+
+
+ // $ANTLR start "ebnf"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:169:1: ebnf : ( ^( SYNPRED block ) | ^( OPTIONAL block ) | ^( CLOSURE block ) | ^( POSITIVE_CLOSURE block ) | SYN_SEMPRED | block );
+ public final void ebnf() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:171:2: ( ^( SYNPRED block ) | ^( OPTIONAL block ) | ^( CLOSURE block ) | ^( POSITIVE_CLOSURE block ) | SYN_SEMPRED | block )
+ int alt39=6;
+ switch ( input.LA(1) ) {
+ case SYNPRED:
+ {
+ alt39=1;
+ }
+ break;
+ case OPTIONAL:
+ {
+ alt39=2;
+ }
+ break;
+ case CLOSURE:
+ {
+ alt39=3;
+ }
+ break;
+ case POSITIVE_CLOSURE:
+ {
+ alt39=4;
+ }
+ break;
+ case SYN_SEMPRED:
+ {
+ alt39=5;
+ }
+ break;
+ case BLOCK:
+ {
+ alt39=6;
+ }
+ break;
+ default:
+ NoViableAltException nvae =
+ new NoViableAltException("", 39, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt39) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:171:4: ^( SYNPRED block )
+ {
+ match(input,SYNPRED,FOLLOW_SYNPRED_in_ebnf950);
+
+ match(input, Token.DOWN, null);
+ pushFollow(FOLLOW_block_in_ebnf952);
+ block();
+
+ state._fsp--;
+
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:172:4: ^( OPTIONAL block )
+ {
+ match(input,OPTIONAL,FOLLOW_OPTIONAL_in_ebnf959);
+
+ match(input, Token.DOWN, null);
+ pushFollow(FOLLOW_block_in_ebnf961);
+ block();
+
+ state._fsp--;
+
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:173:6: ^( CLOSURE block )
+ {
+ match(input,CLOSURE,FOLLOW_CLOSURE_in_ebnf970);
+
+ match(input, Token.DOWN, null);
+ pushFollow(FOLLOW_block_in_ebnf972);
+ block();
+
+ state._fsp--;
+
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 4 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:174:7: ^( POSITIVE_CLOSURE block )
+ {
+ match(input,POSITIVE_CLOSURE,FOLLOW_POSITIVE_CLOSURE_in_ebnf982);
+
+ match(input, Token.DOWN, null);
+ pushFollow(FOLLOW_block_in_ebnf984);
+ block();
+
+ state._fsp--;
+
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 5 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:175:4: SYN_SEMPRED
+ {
+ match(input,SYN_SEMPRED,FOLLOW_SYN_SEMPRED_in_ebnf990);
+
+ }
+ break;
+ case 6 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:176:4: block
+ {
+ pushFollow(FOLLOW_block_in_ebnf995);
+ block();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "ebnf"
+
+
+ // $ANTLR start "notTerminal"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:179:1: notTerminal : ( CHAR_LITERAL | TOKEN_REF | STRING_LITERAL );
+ public final void notTerminal() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:180:2: ( CHAR_LITERAL | TOKEN_REF | STRING_LITERAL )
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:
+ {
+ if ( (input.LA(1)>=TOKEN_REF && input.LA(1)<=CHAR_LITERAL) ) {
+ input.consume();
+ state.errorRecovery=false;
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ throw mse;
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "notTerminal"
+
+
+ // $ANTLR start "rewrite"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:187:1: rewrite : ( ( ^( '->' SEMPRED rewrite_alternative ) )* ^( '->' rewrite_alternative ) | );
+ public final void rewrite() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:188:2: ( ( ^( '->' SEMPRED rewrite_alternative ) )* ^( '->' rewrite_alternative ) | )
+ int alt41=2;
+ int LA41_0 = input.LA(1);
+
+ if ( (LA41_0==REWRITE) ) {
+ alt41=1;
+ }
+ else if ( (LA41_0==ALT||LA41_0==EOB) ) {
+ alt41=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 41, 0, input);
+
+ throw nvae;
+ }
+ switch (alt41) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:188:4: ( ^( '->' SEMPRED rewrite_alternative ) )* ^( '->' rewrite_alternative )
+ {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:188:4: ( ^( '->' SEMPRED rewrite_alternative ) )*
+ loop40:
+ do {
+ int alt40=2;
+ int LA40_0 = input.LA(1);
+
+ if ( (LA40_0==REWRITE) ) {
+ int LA40_1 = input.LA(2);
+
+ if ( (LA40_1==DOWN) ) {
+ int LA40_2 = input.LA(3);
+
+ if ( (LA40_2==SEMPRED) ) {
+ alt40=1;
+ }
+
+
+ }
+
+
+ }
+
+
+ switch (alt40) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:188:5: ^( '->' SEMPRED rewrite_alternative )
+ {
+ match(input,REWRITE,FOLLOW_REWRITE_in_rewrite1035);
+
+ match(input, Token.DOWN, null);
+ match(input,SEMPRED,FOLLOW_SEMPRED_in_rewrite1037);
+ pushFollow(FOLLOW_rewrite_alternative_in_rewrite1039);
+ rewrite_alternative();
+
+ state._fsp--;
+
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+
+ default :
+ break loop40;
+ }
+ } while (true);
+
+ match(input,REWRITE,FOLLOW_REWRITE_in_rewrite1045);
+
+ match(input, Token.DOWN, null);
+ pushFollow(FOLLOW_rewrite_alternative_in_rewrite1047);
+ rewrite_alternative();
+
+ state._fsp--;
+
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:190:2:
+ {
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "rewrite"
+
+
+ // $ANTLR start "rewrite_alternative"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:192:1: rewrite_alternative : ( rewrite_template | rewrite_tree_alternative | ^( ALT EPSILON EOA ) );
+ public final void rewrite_alternative() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:193:2: ( rewrite_template | rewrite_tree_alternative | ^( ALT EPSILON EOA ) )
+ int alt42=3;
+ int LA42_0 = input.LA(1);
+
+ if ( (LA42_0==TEMPLATE||LA42_0==ACTION) ) {
+ alt42=1;
+ }
+ else if ( (LA42_0==ALT) ) {
+ int LA42_2 = input.LA(2);
+
+ if ( (LA42_2==DOWN) ) {
+ int LA42_3 = input.LA(3);
+
+ if ( (LA42_3==EPSILON) ) {
+ alt42=3;
+ }
+ else if ( ((LA42_3>=BLOCK && LA42_3<=POSITIVE_CLOSURE)||LA42_3==LABEL||LA42_3==TREE_BEGIN||(LA42_3>=TOKEN_REF && LA42_3<=ACTION)||LA42_3==RULE_REF) ) {
+ alt42=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 42, 3, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 42, 2, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 42, 0, input);
+
+ throw nvae;
+ }
+ switch (alt42) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:193:4: rewrite_template
+ {
+ pushFollow(FOLLOW_rewrite_template_in_rewrite_alternative1062);
+ rewrite_template();
+
+ state._fsp--;
+
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:194:4: rewrite_tree_alternative
+ {
+ pushFollow(FOLLOW_rewrite_tree_alternative_in_rewrite_alternative1067);
+ rewrite_tree_alternative();
+
+ state._fsp--;
+
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:195:9: ^( ALT EPSILON EOA )
+ {
+ match(input,ALT,FOLLOW_ALT_in_rewrite_alternative1078);
+
+ match(input, Token.DOWN, null);
+ match(input,EPSILON,FOLLOW_EPSILON_in_rewrite_alternative1080);
+ match(input,EOA,FOLLOW_EOA_in_rewrite_alternative1082);
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "rewrite_alternative"
+
+
+ // $ANTLR start "rewrite_tree_block"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:198:1: rewrite_tree_block : ^( BLOCK rewrite_tree_alternative EOB ) ;
+ public final void rewrite_tree_block() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:199:5: ( ^( BLOCK rewrite_tree_alternative EOB ) )
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:199:9: ^( BLOCK rewrite_tree_alternative EOB )
+ {
+ match(input,BLOCK,FOLLOW_BLOCK_in_rewrite_tree_block1101);
+
+ match(input, Token.DOWN, null);
+ pushFollow(FOLLOW_rewrite_tree_alternative_in_rewrite_tree_block1103);
+ rewrite_tree_alternative();
+
+ state._fsp--;
+
+ match(input,EOB,FOLLOW_EOB_in_rewrite_tree_block1105);
+
+ match(input, Token.UP, null);
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "rewrite_tree_block"
+
+
+ // $ANTLR start "rewrite_tree_alternative"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:202:1: rewrite_tree_alternative : ^( ALT ( rewrite_tree_element )+ EOA ) ;
+ public final void rewrite_tree_alternative() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:203:5: ( ^( ALT ( rewrite_tree_element )+ EOA ) )
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:203:7: ^( ALT ( rewrite_tree_element )+ EOA )
+ {
+ match(input,ALT,FOLLOW_ALT_in_rewrite_tree_alternative1124);
+
+ match(input, Token.DOWN, null);
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:203:13: ( rewrite_tree_element )+
+ int cnt43=0;
+ loop43:
+ do {
+ int alt43=2;
+ int LA43_0 = input.LA(1);
+
+ if ( ((LA43_0>=BLOCK && LA43_0<=POSITIVE_CLOSURE)||LA43_0==LABEL||LA43_0==TREE_BEGIN||(LA43_0>=TOKEN_REF && LA43_0<=ACTION)||LA43_0==RULE_REF) ) {
+ alt43=1;
+ }
+
+
+ switch (alt43) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:203:13: rewrite_tree_element
+ {
+ pushFollow(FOLLOW_rewrite_tree_element_in_rewrite_tree_alternative1126);
+ rewrite_tree_element();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ default :
+ if ( cnt43 >= 1 ) break loop43;
+ EarlyExitException eee =
+ new EarlyExitException(43, input);
+ throw eee;
+ }
+ cnt43++;
+ } while (true);
+
+ match(input,EOA,FOLLOW_EOA_in_rewrite_tree_alternative1129);
+
+ match(input, Token.UP, null);
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "rewrite_tree_alternative"
+
+
+ // $ANTLR start "rewrite_tree_element"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:206:1: rewrite_tree_element : ( rewrite_tree_atom | rewrite_tree | rewrite_tree_block | rewrite_tree_ebnf );
+ public final void rewrite_tree_element() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:207:2: ( rewrite_tree_atom | rewrite_tree | rewrite_tree_block | rewrite_tree_ebnf )
+ int alt44=4;
+ switch ( input.LA(1) ) {
+ case LABEL:
+ case TOKEN_REF:
+ case STRING_LITERAL:
+ case CHAR_LITERAL:
+ case ACTION:
+ case RULE_REF:
+ {
+ alt44=1;
+ }
+ break;
+ case TREE_BEGIN:
+ {
+ alt44=2;
+ }
+ break;
+ case BLOCK:
+ {
+ alt44=3;
+ }
+ break;
+ case OPTIONAL:
+ case CLOSURE:
+ case POSITIVE_CLOSURE:
+ {
+ alt44=4;
+ }
+ break;
+ default:
+ NoViableAltException nvae =
+ new NoViableAltException("", 44, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt44) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:207:4: rewrite_tree_atom
+ {
+ pushFollow(FOLLOW_rewrite_tree_atom_in_rewrite_tree_element1144);
+ rewrite_tree_atom();
+
+ state._fsp--;
+
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:208:4: rewrite_tree
+ {
+ pushFollow(FOLLOW_rewrite_tree_in_rewrite_tree_element1149);
+ rewrite_tree();
+
+ state._fsp--;
+
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:209:6: rewrite_tree_block
+ {
+ pushFollow(FOLLOW_rewrite_tree_block_in_rewrite_tree_element1156);
+ rewrite_tree_block();
+
+ state._fsp--;
+
+
+ }
+ break;
+ case 4 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:210:6: rewrite_tree_ebnf
+ {
+ pushFollow(FOLLOW_rewrite_tree_ebnf_in_rewrite_tree_element1163);
+ rewrite_tree_ebnf();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "rewrite_tree_element"
+
+
+ // $ANTLR start "rewrite_tree_atom"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:213:1: rewrite_tree_atom : ( CHAR_LITERAL | TOKEN_REF | ^( TOKEN_REF ARG_ACTION ) | RULE_REF | STRING_LITERAL | LABEL | ACTION );
+ public final void rewrite_tree_atom() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:214:5: ( CHAR_LITERAL | TOKEN_REF | ^( TOKEN_REF ARG_ACTION ) | RULE_REF | STRING_LITERAL | LABEL | ACTION )
+ int alt45=7;
+ switch ( input.LA(1) ) {
+ case CHAR_LITERAL:
+ {
+ alt45=1;
+ }
+ break;
+ case TOKEN_REF:
+ {
+ int LA45_2 = input.LA(2);
+
+ if ( (LA45_2==DOWN) ) {
+ alt45=3;
+ }
+ else if ( (LA45_2==UP||(LA45_2>=BLOCK && LA45_2<=POSITIVE_CLOSURE)||LA45_2==EOA||LA45_2==LABEL||LA45_2==TREE_BEGIN||(LA45_2>=TOKEN_REF && LA45_2<=ACTION)||LA45_2==RULE_REF) ) {
+ alt45=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 45, 2, input);
+
+ throw nvae;
+ }
+ }
+ break;
+ case RULE_REF:
+ {
+ alt45=4;
+ }
+ break;
+ case STRING_LITERAL:
+ {
+ alt45=5;
+ }
+ break;
+ case LABEL:
+ {
+ alt45=6;
+ }
+ break;
+ case ACTION:
+ {
+ alt45=7;
+ }
+ break;
+ default:
+ NoViableAltException nvae =
+ new NoViableAltException("", 45, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt45) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:214:9: CHAR_LITERAL
+ {
+ match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_rewrite_tree_atom1179);
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:215:6: TOKEN_REF
+ {
+ match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_rewrite_tree_atom1186);
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:216:6: ^( TOKEN_REF ARG_ACTION )
+ {
+ match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_rewrite_tree_atom1194);
+
+ match(input, Token.DOWN, null);
+ match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_rewrite_tree_atom1196);
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 4 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:217:9: RULE_REF
+ {
+ match(input,RULE_REF,FOLLOW_RULE_REF_in_rewrite_tree_atom1208);
+
+ }
+ break;
+ case 5 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:218:6: STRING_LITERAL
+ {
+ match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_rewrite_tree_atom1215);
+
+ }
+ break;
+ case 6 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:219:6: LABEL
+ {
+ match(input,LABEL,FOLLOW_LABEL_in_rewrite_tree_atom1222);
+
+ }
+ break;
+ case 7 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:220:4: ACTION
+ {
+ match(input,ACTION,FOLLOW_ACTION_in_rewrite_tree_atom1227);
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "rewrite_tree_atom"
+
+
+ // $ANTLR start "rewrite_tree_ebnf"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:223:1: rewrite_tree_ebnf : ( ^( OPTIONAL rewrite_tree_block ) | ^( CLOSURE rewrite_tree_block ) | ^( POSITIVE_CLOSURE rewrite_tree_block ) );
+ public final void rewrite_tree_ebnf() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:224:2: ( ^( OPTIONAL rewrite_tree_block ) | ^( CLOSURE rewrite_tree_block ) | ^( POSITIVE_CLOSURE rewrite_tree_block ) )
+ int alt46=3;
+ switch ( input.LA(1) ) {
+ case OPTIONAL:
+ {
+ alt46=1;
+ }
+ break;
+ case CLOSURE:
+ {
+ alt46=2;
+ }
+ break;
+ case POSITIVE_CLOSURE:
+ {
+ alt46=3;
+ }
+ break;
+ default:
+ NoViableAltException nvae =
+ new NoViableAltException("", 46, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt46) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:224:4: ^( OPTIONAL rewrite_tree_block )
+ {
+ match(input,OPTIONAL,FOLLOW_OPTIONAL_in_rewrite_tree_ebnf1239);
+
+ match(input, Token.DOWN, null);
+ pushFollow(FOLLOW_rewrite_tree_block_in_rewrite_tree_ebnf1241);
+ rewrite_tree_block();
+
+ state._fsp--;
+
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:225:6: ^( CLOSURE rewrite_tree_block )
+ {
+ match(input,CLOSURE,FOLLOW_CLOSURE_in_rewrite_tree_ebnf1250);
+
+ match(input, Token.DOWN, null);
+ pushFollow(FOLLOW_rewrite_tree_block_in_rewrite_tree_ebnf1252);
+ rewrite_tree_block();
+
+ state._fsp--;
+
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:226:7: ^( POSITIVE_CLOSURE rewrite_tree_block )
+ {
+ match(input,POSITIVE_CLOSURE,FOLLOW_POSITIVE_CLOSURE_in_rewrite_tree_ebnf1262);
+
+ match(input, Token.DOWN, null);
+ pushFollow(FOLLOW_rewrite_tree_block_in_rewrite_tree_ebnf1264);
+ rewrite_tree_block();
+
+ state._fsp--;
+
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "rewrite_tree_ebnf"
+
+
+ // $ANTLR start "rewrite_tree"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:229:1: rewrite_tree : ^( TREE_BEGIN rewrite_tree_atom ( rewrite_tree_element )* ) ;
+ public final void rewrite_tree() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:230:2: ( ^( TREE_BEGIN rewrite_tree_atom ( rewrite_tree_element )* ) )
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:230:4: ^( TREE_BEGIN rewrite_tree_atom ( rewrite_tree_element )* )
+ {
+ match(input,TREE_BEGIN,FOLLOW_TREE_BEGIN_in_rewrite_tree1278);
+
+ match(input, Token.DOWN, null);
+ pushFollow(FOLLOW_rewrite_tree_atom_in_rewrite_tree1280);
+ rewrite_tree_atom();
+
+ state._fsp--;
+
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:230:35: ( rewrite_tree_element )*
+ loop47:
+ do {
+ int alt47=2;
+ int LA47_0 = input.LA(1);
+
+ if ( ((LA47_0>=BLOCK && LA47_0<=POSITIVE_CLOSURE)||LA47_0==LABEL||LA47_0==TREE_BEGIN||(LA47_0>=TOKEN_REF && LA47_0<=ACTION)||LA47_0==RULE_REF) ) {
+ alt47=1;
+ }
+
+
+ switch (alt47) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:230:35: rewrite_tree_element
+ {
+ pushFollow(FOLLOW_rewrite_tree_element_in_rewrite_tree1282);
+ rewrite_tree_element();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ default :
+ break loop47;
+ }
+ } while (true);
+
+
+ match(input, Token.UP, null);
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "rewrite_tree"
+
+
+ // $ANTLR start "rewrite_template"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:233:1: rewrite_template : ( ^( TEMPLATE ID rewrite_template_args ( DOUBLE_QUOTE_STRING_LITERAL | DOUBLE_ANGLE_STRING_LITERAL ) ) | rewrite_template_ref | rewrite_indirect_template_head | ACTION );
+ public final void rewrite_template() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:234:2: ( ^( TEMPLATE ID rewrite_template_args ( DOUBLE_QUOTE_STRING_LITERAL | DOUBLE_ANGLE_STRING_LITERAL ) ) | rewrite_template_ref | rewrite_indirect_template_head | ACTION )
+ int alt48=4;
+ alt48 = dfa48.predict(input);
+ switch (alt48) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:234:6: ^( TEMPLATE ID rewrite_template_args ( DOUBLE_QUOTE_STRING_LITERAL | DOUBLE_ANGLE_STRING_LITERAL ) )
+ {
+ match(input,TEMPLATE,FOLLOW_TEMPLATE_in_rewrite_template1300);
+
+ match(input, Token.DOWN, null);
+ match(input,ID,FOLLOW_ID_in_rewrite_template1302);
+ pushFollow(FOLLOW_rewrite_template_args_in_rewrite_template1304);
+ rewrite_template_args();
+
+ state._fsp--;
+
+ if ( (input.LA(1)>=DOUBLE_QUOTE_STRING_LITERAL && input.LA(1)<=DOUBLE_ANGLE_STRING_LITERAL) ) {
+ input.consume();
+ state.errorRecovery=false;
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ throw mse;
+ }
+
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:237:4: rewrite_template_ref
+ {
+ pushFollow(FOLLOW_rewrite_template_ref_in_rewrite_template1327);
+ rewrite_template_ref();
+
+ state._fsp--;
+
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:238:4: rewrite_indirect_template_head
+ {
+ pushFollow(FOLLOW_rewrite_indirect_template_head_in_rewrite_template1332);
+ rewrite_indirect_template_head();
+
+ state._fsp--;
+
+
+ }
+ break;
+ case 4 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:239:4: ACTION
+ {
+ match(input,ACTION,FOLLOW_ACTION_in_rewrite_template1337);
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "rewrite_template"
+
+
+ // $ANTLR start "rewrite_template_ref"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:242:1: rewrite_template_ref : ^( TEMPLATE ID rewrite_template_args ) ;
+ public final void rewrite_template_ref() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:244:2: ( ^( TEMPLATE ID rewrite_template_args ) )
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:244:4: ^( TEMPLATE ID rewrite_template_args )
+ {
+ match(input,TEMPLATE,FOLLOW_TEMPLATE_in_rewrite_template_ref1351);
+
+ match(input, Token.DOWN, null);
+ match(input,ID,FOLLOW_ID_in_rewrite_template_ref1353);
+ pushFollow(FOLLOW_rewrite_template_args_in_rewrite_template_ref1355);
+ rewrite_template_args();
+
+ state._fsp--;
+
+
+ match(input, Token.UP, null);
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "rewrite_template_ref"
+
+
+ // $ANTLR start "rewrite_indirect_template_head"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:247:1: rewrite_indirect_template_head : ^( TEMPLATE ACTION rewrite_template_args ) ;
+ public final void rewrite_indirect_template_head() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:249:2: ( ^( TEMPLATE ACTION rewrite_template_args ) )
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:249:4: ^( TEMPLATE ACTION rewrite_template_args )
+ {
+ match(input,TEMPLATE,FOLLOW_TEMPLATE_in_rewrite_indirect_template_head1370);
+
+ match(input, Token.DOWN, null);
+ match(input,ACTION,FOLLOW_ACTION_in_rewrite_indirect_template_head1372);
+ pushFollow(FOLLOW_rewrite_template_args_in_rewrite_indirect_template_head1374);
+ rewrite_template_args();
+
+ state._fsp--;
+
+
+ match(input, Token.UP, null);
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "rewrite_indirect_template_head"
+
+
+ // $ANTLR start "rewrite_template_args"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:252:1: rewrite_template_args : ( ^( ARGLIST ( rewrite_template_arg )+ ) | ARGLIST );
+ public final void rewrite_template_args() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:253:2: ( ^( ARGLIST ( rewrite_template_arg )+ ) | ARGLIST )
+ int alt50=2;
+ int LA50_0 = input.LA(1);
+
+ if ( (LA50_0==ARGLIST) ) {
+ int LA50_1 = input.LA(2);
+
+ if ( (LA50_1==DOWN) ) {
+ alt50=1;
+ }
+ else if ( (LA50_1==UP||(LA50_1>=DOUBLE_QUOTE_STRING_LITERAL && LA50_1<=DOUBLE_ANGLE_STRING_LITERAL)) ) {
+ alt50=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 50, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 50, 0, input);
+
+ throw nvae;
+ }
+ switch (alt50) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:253:4: ^( ARGLIST ( rewrite_template_arg )+ )
+ {
+ match(input,ARGLIST,FOLLOW_ARGLIST_in_rewrite_template_args1387);
+
+ match(input, Token.DOWN, null);
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:253:14: ( rewrite_template_arg )+
+ int cnt49=0;
+ loop49:
+ do {
+ int alt49=2;
+ int LA49_0 = input.LA(1);
+
+ if ( (LA49_0==ARG) ) {
+ alt49=1;
+ }
+
+
+ switch (alt49) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:253:14: rewrite_template_arg
+ {
+ pushFollow(FOLLOW_rewrite_template_arg_in_rewrite_template_args1389);
+ rewrite_template_arg();
+
+ state._fsp--;
+
+
+ }
+ break;
+
+ default :
+ if ( cnt49 >= 1 ) break loop49;
+ EarlyExitException eee =
+ new EarlyExitException(49, input);
+ throw eee;
+ }
+ cnt49++;
+ } while (true);
+
+
+ match(input, Token.UP, null);
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:254:4: ARGLIST
+ {
+ match(input,ARGLIST,FOLLOW_ARGLIST_in_rewrite_template_args1396);
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "rewrite_template_args"
+
+
+ // $ANTLR start "rewrite_template_arg"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:257:1: rewrite_template_arg : ^( ARG ID ACTION ) ;
+ public final void rewrite_template_arg() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:258:2: ( ^( ARG ID ACTION ) )
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:258:6: ^( ARG ID ACTION )
+ {
+ match(input,ARG,FOLLOW_ARG_in_rewrite_template_arg1410);
+
+ match(input, Token.DOWN, null);
+ match(input,ID,FOLLOW_ID_in_rewrite_template_arg1412);
+ match(input,ACTION,FOLLOW_ACTION_in_rewrite_template_arg1414);
+
+ match(input, Token.UP, null);
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "rewrite_template_arg"
+
+
+ // $ANTLR start "qid"
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:261:1: qid : ID ( '.' ID )* ;
+ public final void qid() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:261:5: ( ID ( '.' ID )* )
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:261:7: ID ( '.' ID )*
+ {
+ match(input,ID,FOLLOW_ID_in_qid1425);
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:261:10: ( '.' ID )*
+ loop51:
+ do {
+ int alt51=2;
+ int LA51_0 = input.LA(1);
+
+ if ( (LA51_0==90) ) {
+ alt51=1;
+ }
+
+
+ switch (alt51) {
+ case 1 :
+ // org/antlr/grammar/v3/ANTLRv3Tree.g:261:11: '.' ID
+ {
+ match(input,90,FOLLOW_90_in_qid1428);
+ match(input,ID,FOLLOW_ID_in_qid1430);
+
+ }
+ break;
+
+ default :
+ break loop51;
+ }
+ } while (true);
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "qid"
+
+ // Delegated rules
+
+
+ protected DFA33 dfa33 = new DFA33(this);
+ protected DFA38 dfa38 = new DFA38(this);
+ protected DFA48 dfa48 = new DFA48(this);
+ static final String DFA33_eotS =
+ "\14\uffff";
+ static final String DFA33_eofS =
+ "\14\uffff";
+ static final String DFA33_minS =
+ "\1\10\1\2\6\uffff\1\24\1\10\2\uffff";
+ static final String DFA33_maxS =
+ "\1\132\1\2\6\uffff\1\24\1\132\2\uffff";
+ static final String DFA33_acceptS =
+ "\2\uffff\1\3\1\4\1\5\1\6\1\7\1\10\2\uffff\1\1\1\2";
+ static final String DFA33_specialS =
+ "\14\uffff}>";
+ static final String[] DFA33_transitionS = {
+ "\5\3\1\uffff\1\2\20\uffff\1\5\1\6\1\3\2\uffff\1\7\2\2\2\uffff"+
+ "\2\1\1\uffff\3\2\1\4\3\uffff\1\2\43\uffff\1\2\2\uffff\1\2",
+ "\1\10",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\11",
+ "\1\12\5\uffff\1\13\26\uffff\2\13\5\uffff\3\13\4\uffff\1\13"+
+ "\43\uffff\1\13\2\uffff\1\13",
+ "",
+ ""
+ };
+
+ static final short[] DFA33_eot = DFA.unpackEncodedString(DFA33_eotS);
+ static final short[] DFA33_eof = DFA.unpackEncodedString(DFA33_eofS);
+ static final char[] DFA33_min = DFA.unpackEncodedStringToUnsignedChars(DFA33_minS);
+ static final char[] DFA33_max = DFA.unpackEncodedStringToUnsignedChars(DFA33_maxS);
+ static final short[] DFA33_accept = DFA.unpackEncodedString(DFA33_acceptS);
+ static final short[] DFA33_special = DFA.unpackEncodedString(DFA33_specialS);
+ static final short[][] DFA33_transition;
+
+ static {
+ int numStates = DFA33_transitionS.length;
+ DFA33_transition = new short[numStates][];
+ for (int i=0; i<numStates; i++) {
+ DFA33_transition[i] = DFA.unpackEncodedString(DFA33_transitionS[i]);
+ }
+ }
+
+ class DFA33 extends DFA {
+
+ public DFA33(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 33;
+ this.eot = DFA33_eot;
+ this.eof = DFA33_eof;
+ this.min = DFA33_min;
+ this.max = DFA33_max;
+ this.accept = DFA33_accept;
+ this.special = DFA33_special;
+ this.transition = DFA33_transition;
+ }
+ public String getDescription() {
+ return "140:1: element : ( ^( ( '=' | '+=' ) ID block ) | ^( ( '=' | '+=' ) ID atom ) | atom | ebnf | ACTION | SEMPRED | GATED_SEMPRED | ^( TREE_BEGIN ( element )+ ) );";
+ }
+ }
+ static final String DFA38_eotS =
+ "\32\uffff";
+ static final String DFA38_eofS =
+ "\32\uffff";
+ static final String DFA38_minS =
+ "\1\16\2\uffff\6\2\1\10\4\uffff\1\60\7\uffff\1\3\3\uffff";
+ static final String DFA38_maxS =
+ "\1\132\2\uffff\1\2\5\132\1\56\4\uffff\1\62\7\uffff\1\60\3\uffff";
+ static final String DFA38_acceptS =
+ "\1\uffff\1\1\1\2\7\uffff\1\5\1\6\1\10\1\7\1\uffff\1\11\1\16\1\15"+
+ "\1\20\1\17\1\4\1\3\1\uffff\1\12\1\14\1\13";
+ static final String DFA38_specialS =
+ "\32\uffff}>";
+ static final String[] DFA38_transitionS = {
+ "\1\2\26\uffff\2\1\5\uffff\1\6\1\7\1\5\4\uffff\1\4\43\uffff\1"+
+ "\3\2\uffff\1\10",
+ "",
+ "",
+ "\1\11",
+ "\1\12\1\13\4\uffff\5\13\1\uffff\1\13\4\uffff\1\13\13\uffff"+
+ "\3\13\2\uffff\3\13\2\uffff\2\13\1\uffff\4\13\3\uffff\1\13\43"+
+ "\uffff\1\13\2\uffff\1\13",
+ "\1\14\1\15\4\uffff\5\15\1\uffff\1\15\4\uffff\1\15\13\uffff"+
+ "\3\15\2\uffff\3\15\2\uffff\2\15\1\uffff\4\15\3\uffff\1\15\43"+
+ "\uffff\1\15\2\uffff\1\15",
+ "\1\16\1\17\4\uffff\5\17\1\uffff\1\17\4\uffff\1\17\13\uffff"+
+ "\3\17\2\uffff\3\17\2\uffff\2\17\1\uffff\4\17\3\uffff\1\17\43"+
+ "\uffff\1\17\2\uffff\1\17",
+ "\1\20\1\21\4\uffff\5\21\1\uffff\1\21\4\uffff\1\21\13\uffff"+
+ "\3\21\2\uffff\3\21\2\uffff\2\21\1\uffff\4\21\3\uffff\1\21\43"+
+ "\uffff\1\21\2\uffff\1\21",
+ "\1\22\1\23\4\uffff\5\23\1\uffff\1\23\4\uffff\1\23\13\uffff"+
+ "\3\23\2\uffff\3\23\2\uffff\2\23\1\uffff\4\23\3\uffff\1\23\43"+
+ "\uffff\1\23\2\uffff\1\23",
+ "\1\24\43\uffff\3\25",
+ "",
+ "",
+ "",
+ "",
+ "\1\27\1\uffff\1\26",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\30\54\uffff\1\31",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] DFA38_eot = DFA.unpackEncodedString(DFA38_eotS);
+ static final short[] DFA38_eof = DFA.unpackEncodedString(DFA38_eofS);
+ static final char[] DFA38_min = DFA.unpackEncodedStringToUnsignedChars(DFA38_minS);
+ static final char[] DFA38_max = DFA.unpackEncodedStringToUnsignedChars(DFA38_maxS);
+ static final short[] DFA38_accept = DFA.unpackEncodedString(DFA38_acceptS);
+ static final short[] DFA38_special = DFA.unpackEncodedString(DFA38_specialS);
+ static final short[][] DFA38_transition;
+
+ static {
+ int numStates = DFA38_transitionS.length;
+ DFA38_transition = new short[numStates][];
+ for (int i=0; i<numStates; i++) {
+ DFA38_transition[i] = DFA.unpackEncodedString(DFA38_transitionS[i]);
+ }
+ }
+
+ class DFA38 extends DFA {
+
+ public DFA38(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 38;
+ this.eot = DFA38_eot;
+ this.eof = DFA38_eof;
+ this.min = DFA38_min;
+ this.max = DFA38_max;
+ this.accept = DFA38_accept;
+ this.special = DFA38_special;
+ this.transition = DFA38_transition;
+ }
+ public String getDescription() {
+ return "151:1: atom : ( ^( ( '^' | '!' ) atom ) | ^( CHAR_RANGE CHAR_LITERAL CHAR_LITERAL ( optionsSpec )? ) | ^( '~' notTerminal ( optionsSpec )? ) | ^( '~' block ( optionsSpec )? ) | ^( RULE_REF ARG_ACTION ) | RULE_REF | CHAR_LITERAL | ^( CHAR_LITERAL optionsSpec ) | TOKEN_REF | ^( TOKEN_REF optionsSpec ) | ^( TOKEN_REF ARG_ACTION optionsSpec ) | ^( TOKEN_REF ARG_ACTION ) | STRING_LITERAL | ^( STRING_LITERAL optionsSpec ) | '.' | ^( '.' ( optionsSpec )? ) );";
+ }
+ }
+ static final String DFA48_eotS =
+ "\20\uffff";
+ static final String DFA48_eofS =
+ "\20\uffff";
+ static final String DFA48_minS =
+ "\1\35\1\2\1\uffff\1\24\1\26\1\uffff\1\2\1\25\2\uffff\1\2\1\24\1"+
+ "\57\3\3";
+ static final String DFA48_maxS =
+ "\1\57\1\2\1\uffff\1\57\1\26\1\uffff\1\65\1\25\2\uffff\1\2\1\24\1"+
+ "\57\1\3\1\25\1\65";
+ static final String DFA48_acceptS =
+ "\2\uffff\1\4\2\uffff\1\3\2\uffff\1\2\1\1\6\uffff";
+ static final String DFA48_specialS =
+ "\20\uffff}>";
+ static final String[] DFA48_transitionS = {
+ "\1\1\21\uffff\1\2",
+ "\1\3",
+ "",
+ "\1\4\32\uffff\1\5",
+ "\1\6",
+ "",
+ "\1\7\1\10\60\uffff\2\11",
+ "\1\12",
+ "",
+ "",
+ "\1\13",
+ "\1\14",
+ "\1\15",
+ "\1\16",
+ "\1\17\21\uffff\1\12",
+ "\1\10\60\uffff\2\11"
+ };
+
+ static final short[] DFA48_eot = DFA.unpackEncodedString(DFA48_eotS);
+ static final short[] DFA48_eof = DFA.unpackEncodedString(DFA48_eofS);
+ static final char[] DFA48_min = DFA.unpackEncodedStringToUnsignedChars(DFA48_minS);
+ static final char[] DFA48_max = DFA.unpackEncodedStringToUnsignedChars(DFA48_maxS);
+ static final short[] DFA48_accept = DFA.unpackEncodedString(DFA48_acceptS);
+ static final short[] DFA48_special = DFA.unpackEncodedString(DFA48_specialS);
+ static final short[][] DFA48_transition;
+
+ static {
+ int numStates = DFA48_transitionS.length;
+ DFA48_transition = new short[numStates][];
+ for (int i=0; i<numStates; i++) {
+ DFA48_transition[i] = DFA.unpackEncodedString(DFA48_transitionS[i]);
+ }
+ }
+
+ class DFA48 extends DFA {
+
+ public DFA48(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 48;
+ this.eot = DFA48_eot;
+ this.eof = DFA48_eof;
+ this.min = DFA48_min;
+ this.max = DFA48_max;
+ this.accept = DFA48_accept;
+ this.special = DFA48_special;
+ this.transition = DFA48_transition;
+ }
+ public String getDescription() {
+ return "233:1: rewrite_template : ( ^( TEMPLATE ID rewrite_template_args ( DOUBLE_QUOTE_STRING_LITERAL | DOUBLE_ANGLE_STRING_LITERAL ) ) | rewrite_template_ref | rewrite_indirect_template_head | ACTION );";
+ }
+ }
+
+
+ public static final BitSet FOLLOW_grammarType_in_grammarDef52 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_ID_in_grammarDef54 = new BitSet(new long[]{0x0001090040000090L});
+ public static final BitSet FOLLOW_DOC_COMMENT_in_grammarDef56 = new BitSet(new long[]{0x0001090040000090L});
+ public static final BitSet FOLLOW_optionsSpec_in_grammarDef59 = new BitSet(new long[]{0x0001090040000090L});
+ public static final BitSet FOLLOW_tokensSpec_in_grammarDef62 = new BitSet(new long[]{0x0001090040000090L});
+ public static final BitSet FOLLOW_attrScope_in_grammarDef65 = new BitSet(new long[]{0x0001090040000090L});
+ public static final BitSet FOLLOW_action_in_grammarDef68 = new BitSet(new long[]{0x0001090040000090L});
+ public static final BitSet FOLLOW_rule_in_grammarDef71 = new BitSet(new long[]{0x0001090040000098L});
+ public static final BitSet FOLLOW_set_in_grammarType0 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_TOKENS_in_tokensSpec127 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_tokenSpec_in_tokensSpec129 = new BitSet(new long[]{0x0000120000000008L});
+ public static final BitSet FOLLOW_LABEL_ASSIGN_in_tokenSpec143 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_TOKEN_REF_in_tokenSpec145 = new BitSet(new long[]{0x0000200000000000L});
+ public static final BitSet FOLLOW_STRING_LITERAL_in_tokenSpec147 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_LABEL_ASSIGN_in_tokenSpec154 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_TOKEN_REF_in_tokenSpec156 = new BitSet(new long[]{0x0000400000000000L});
+ public static final BitSet FOLLOW_CHAR_LITERAL_in_tokenSpec158 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_TOKEN_REF_in_tokenSpec164 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_SCOPE_in_attrScope176 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_ID_in_attrScope178 = new BitSet(new long[]{0x0000800000000000L});
+ public static final BitSet FOLLOW_ACTION_in_attrScope180 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_AT_in_action193 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_ID_in_action195 = new BitSet(new long[]{0x0000000000100000L});
+ public static final BitSet FOLLOW_ID_in_action197 = new BitSet(new long[]{0x0000800000000000L});
+ public static final BitSet FOLLOW_ACTION_in_action199 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_AT_in_action206 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_ID_in_action208 = new BitSet(new long[]{0x0000800000000000L});
+ public static final BitSet FOLLOW_ACTION_in_action210 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_OPTIONS_in_optionsSpec223 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_option_in_optionsSpec225 = new BitSet(new long[]{0x0000020000100008L});
+ public static final BitSet FOLLOW_qid_in_option243 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_LABEL_ASSIGN_in_option253 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_ID_in_option255 = new BitSet(new long[]{0x0002600000100000L});
+ public static final BitSet FOLLOW_optionValue_in_option257 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_set_in_optionValue0 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_in_rule323 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_ID_in_rule325 = new BitSet(new long[]{0x0001010840A00100L,0x000000000000B800L});
+ public static final BitSet FOLLOW_modifier_in_rule327 = new BitSet(new long[]{0x0001010840A00100L,0x000000000000B800L});
+ public static final BitSet FOLLOW_ARG_in_rule332 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_ARG_ACTION_in_rule334 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_RET_in_rule341 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_ARG_ACTION_in_rule343 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_throwsSpec_in_rule356 = new BitSet(new long[]{0x0001010840A00100L,0x000000000000B800L});
+ public static final BitSet FOLLOW_optionsSpec_in_rule359 = new BitSet(new long[]{0x0001010840A00100L,0x000000000000B800L});
+ public static final BitSet FOLLOW_ruleScopeSpec_in_rule362 = new BitSet(new long[]{0x0001010840A00100L,0x000000000000B800L});
+ public static final BitSet FOLLOW_ruleAction_in_rule365 = new BitSet(new long[]{0x0001010840A00100L,0x000000000000B800L});
+ public static final BitSet FOLLOW_altList_in_rule376 = new BitSet(new long[]{0x0000000000020000L,0x0000000000300000L});
+ public static final BitSet FOLLOW_exceptionGroup_in_rule386 = new BitSet(new long[]{0x0000000000020000L});
+ public static final BitSet FOLLOW_EOR_in_rule389 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_set_in_modifier0 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_AT_in_ruleAction428 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_ID_in_ruleAction430 = new BitSet(new long[]{0x0000800000000000L});
+ public static final BitSet FOLLOW_ACTION_in_ruleAction432 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_79_in_throwsSpec445 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_ID_in_throwsSpec447 = new BitSet(new long[]{0x0000000000100008L});
+ public static final BitSet FOLLOW_SCOPE_in_ruleScopeSpec461 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_ACTION_in_ruleScopeSpec463 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_SCOPE_in_ruleScopeSpec470 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_ACTION_in_ruleScopeSpec472 = new BitSet(new long[]{0x0000000000100000L});
+ public static final BitSet FOLLOW_ID_in_ruleScopeSpec474 = new BitSet(new long[]{0x0000000000100008L});
+ public static final BitSet FOLLOW_SCOPE_in_ruleScopeSpec482 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_ID_in_ruleScopeSpec484 = new BitSet(new long[]{0x0000000000100008L});
+ public static final BitSet FOLLOW_BLOCK_in_block504 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_optionsSpec_in_block506 = new BitSet(new long[]{0x0000000000010000L});
+ public static final BitSet FOLLOW_alternative_in_block510 = new BitSet(new long[]{0x0000008000050000L});
+ public static final BitSet FOLLOW_rewrite_in_block512 = new BitSet(new long[]{0x0000000000050000L});
+ public static final BitSet FOLLOW_EOB_in_block516 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_BLOCK_in_altList539 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_alternative_in_altList542 = new BitSet(new long[]{0x0000008000050000L});
+ public static final BitSet FOLLOW_rewrite_in_altList544 = new BitSet(new long[]{0x0000000000050000L});
+ public static final BitSet FOLLOW_EOB_in_altList548 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_ALT_in_alternative570 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_element_in_alternative572 = new BitSet(new long[]{0x0008F67380085F00L,0x0000000004800000L});
+ public static final BitSet FOLLOW_EOA_in_alternative575 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_ALT_in_alternative587 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_EPSILON_in_alternative589 = new BitSet(new long[]{0x0000000000080000L});
+ public static final BitSet FOLLOW_EOA_in_alternative591 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_exceptionHandler_in_exceptionGroup606 = new BitSet(new long[]{0x0000000000000002L,0x0000000000300000L});
+ public static final BitSet FOLLOW_finallyClause_in_exceptionGroup609 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_finallyClause_in_exceptionGroup615 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_84_in_exceptionHandler636 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_ARG_ACTION_in_exceptionHandler638 = new BitSet(new long[]{0x0000800000000000L});
+ public static final BitSet FOLLOW_ACTION_in_exceptionHandler640 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_85_in_finallyClause662 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_ACTION_in_finallyClause664 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_set_in_element680 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_ID_in_element686 = new BitSet(new long[]{0x0000000200001F00L});
+ public static final BitSet FOLLOW_block_in_element688 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_set_in_element695 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_ID_in_element701 = new BitSet(new long[]{0x0008706000004000L,0x0000000004800000L});
+ public static final BitSet FOLLOW_atom_in_element703 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_atom_in_element709 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ebnf_in_element714 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ACTION_in_element721 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_SEMPRED_in_element728 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_GATED_SEMPRED_in_element733 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_TREE_BEGIN_in_element741 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_element_in_element743 = new BitSet(new long[]{0x0008F67380085F08L,0x0000000004800000L});
+ public static final BitSet FOLLOW_set_in_atom757 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_atom_in_atom763 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_CHAR_RANGE_in_atom770 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_CHAR_LITERAL_in_atom772 = new BitSet(new long[]{0x0000400000000000L});
+ public static final BitSet FOLLOW_CHAR_LITERAL_in_atom774 = new BitSet(new long[]{0x0001000000000008L});
+ public static final BitSet FOLLOW_optionsSpec_in_atom776 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_87_in_atom784 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_notTerminal_in_atom786 = new BitSet(new long[]{0x0001000000000008L});
+ public static final BitSet FOLLOW_optionsSpec_in_atom788 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_87_in_atom796 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_block_in_atom798 = new BitSet(new long[]{0x0001000000000008L});
+ public static final BitSet FOLLOW_optionsSpec_in_atom800 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_RULE_REF_in_atom811 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_ARG_ACTION_in_atom813 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_RULE_REF_in_atom822 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_CHAR_LITERAL_in_atom832 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_CHAR_LITERAL_in_atom843 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_optionsSpec_in_atom845 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_TOKEN_REF_in_atom854 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_TOKEN_REF_in_atom863 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_optionsSpec_in_atom865 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_TOKEN_REF_in_atom875 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_ARG_ACTION_in_atom877 = new BitSet(new long[]{0x0001000000000000L});
+ public static final BitSet FOLLOW_optionsSpec_in_atom879 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_TOKEN_REF_in_atom889 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_ARG_ACTION_in_atom891 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_STRING_LITERAL_in_atom900 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_STRING_LITERAL_in_atom909 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_optionsSpec_in_atom911 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_90_in_atom920 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_90_in_atom929 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_optionsSpec_in_atom931 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_SYNPRED_in_ebnf950 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_block_in_ebnf952 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_OPTIONAL_in_ebnf959 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_block_in_ebnf961 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_CLOSURE_in_ebnf970 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_block_in_ebnf972 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_POSITIVE_CLOSURE_in_ebnf982 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_block_in_ebnf984 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_SYN_SEMPRED_in_ebnf990 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_block_in_ebnf995 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_set_in_notTerminal0 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_REWRITE_in_rewrite1035 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_SEMPRED_in_rewrite1037 = new BitSet(new long[]{0x0000800020010000L});
+ public static final BitSet FOLLOW_rewrite_alternative_in_rewrite1039 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_REWRITE_in_rewrite1045 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_rewrite_alternative_in_rewrite1047 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_rewrite_template_in_rewrite_alternative1062 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rewrite_tree_alternative_in_rewrite_alternative1067 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ALT_in_rewrite_alternative1078 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_EPSILON_in_rewrite_alternative1080 = new BitSet(new long[]{0x0000000000080000L});
+ public static final BitSet FOLLOW_EOA_in_rewrite_alternative1082 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_BLOCK_in_rewrite_tree_block1101 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_rewrite_tree_alternative_in_rewrite_tree_block1103 = new BitSet(new long[]{0x0000000000040000L});
+ public static final BitSet FOLLOW_EOB_in_rewrite_tree_block1105 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_ALT_in_rewrite_tree_alternative1124 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_rewrite_tree_element_in_rewrite_tree_alternative1126 = new BitSet(new long[]{0x0008F01010080F00L});
+ public static final BitSet FOLLOW_EOA_in_rewrite_tree_alternative1129 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_rewrite_tree_atom_in_rewrite_tree_element1144 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rewrite_tree_in_rewrite_tree_element1149 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rewrite_tree_block_in_rewrite_tree_element1156 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rewrite_tree_ebnf_in_rewrite_tree_element1163 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_CHAR_LITERAL_in_rewrite_tree_atom1179 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_TOKEN_REF_in_rewrite_tree_atom1186 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_TOKEN_REF_in_rewrite_tree_atom1194 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_ARG_ACTION_in_rewrite_tree_atom1196 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_RULE_REF_in_rewrite_tree_atom1208 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_STRING_LITERAL_in_rewrite_tree_atom1215 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_LABEL_in_rewrite_tree_atom1222 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ACTION_in_rewrite_tree_atom1227 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_OPTIONAL_in_rewrite_tree_ebnf1239 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_rewrite_tree_block_in_rewrite_tree_ebnf1241 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_CLOSURE_in_rewrite_tree_ebnf1250 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_rewrite_tree_block_in_rewrite_tree_ebnf1252 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_POSITIVE_CLOSURE_in_rewrite_tree_ebnf1262 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_rewrite_tree_block_in_rewrite_tree_ebnf1264 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_TREE_BEGIN_in_rewrite_tree1278 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_rewrite_tree_atom_in_rewrite_tree1280 = new BitSet(new long[]{0x0008F01010080F08L});
+ public static final BitSet FOLLOW_rewrite_tree_element_in_rewrite_tree1282 = new BitSet(new long[]{0x0008F01010080F08L});
+ public static final BitSet FOLLOW_TEMPLATE_in_rewrite_template1300 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_ID_in_rewrite_template1302 = new BitSet(new long[]{0x0000000000400000L});
+ public static final BitSet FOLLOW_rewrite_template_args_in_rewrite_template1304 = new BitSet(new long[]{0x0030000000000000L});
+ public static final BitSet FOLLOW_set_in_rewrite_template1311 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_rewrite_template_ref_in_rewrite_template1327 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rewrite_indirect_template_head_in_rewrite_template1332 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ACTION_in_rewrite_template1337 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_TEMPLATE_in_rewrite_template_ref1351 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_ID_in_rewrite_template_ref1353 = new BitSet(new long[]{0x0000000000400000L});
+ public static final BitSet FOLLOW_rewrite_template_args_in_rewrite_template_ref1355 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_TEMPLATE_in_rewrite_indirect_template_head1370 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_ACTION_in_rewrite_indirect_template_head1372 = new BitSet(new long[]{0x0000000000400000L});
+ public static final BitSet FOLLOW_rewrite_template_args_in_rewrite_indirect_template_head1374 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_ARGLIST_in_rewrite_template_args1387 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_rewrite_template_arg_in_rewrite_template_args1389 = new BitSet(new long[]{0x0000000000200008L});
+ public static final BitSet FOLLOW_ARGLIST_in_rewrite_template_args1396 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ARG_in_rewrite_template_arg1410 = new BitSet(new long[]{0x0000000000000004L});
+ public static final BitSet FOLLOW_ID_in_rewrite_template_arg1412 = new BitSet(new long[]{0x0000800000000000L});
+ public static final BitSet FOLLOW_ACTION_in_rewrite_template_arg1414 = new BitSet(new long[]{0x0000000000000008L});
+ public static final BitSet FOLLOW_ID_in_qid1425 = new BitSet(new long[]{0x0000000000000002L,0x0000000004000000L});
+ public static final BitSet FOLLOW_90_in_qid1428 = new BitSet(new long[]{0x0000000000100000L});
+ public static final BitSet FOLLOW_ID_in_qid1430 = new BitSet(new long[]{0x0000000000000002L,0x0000000004000000L});
+
+}
\ No newline at end of file
diff --git a/debian/generated-sources/antlr3/org/antlr/grammar/v3/ActionAnalysis.java b/debian/generated-sources/antlr3/org/antlr/grammar/v3/ActionAnalysis.java
new file mode 100644
index 0000000..3b9f4c4
--- /dev/null
+++ b/debian/generated-sources/antlr3/org/antlr/grammar/v3/ActionAnalysis.java
@@ -0,0 +1,425 @@
+// $ANTLR 3.1.3 Mar 17, 2009 19:23:44 org/antlr/grammar/v3/ActionAnalysis.g 2010-05-13 00:10:14
+
+package org.antlr.grammar.v3;
+import org.antlr.runtime.*;
+import org.antlr.tool.*;
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+/** We need to set Rule.referencedPredefinedRuleAttributes before
+ * code generation. This filter looks at an action in context of
+ * its rule and outer alternative number and figures out which
+ * rules have predefined prefs referenced. I need this so I can
+ * remove unusued labels. This also tracks, for labeled rules,
+ * which are referenced by actions.
+ */
+public class ActionAnalysis extends Lexer {
+ public static final int X_Y=5;
+ public static final int ID=4;
+ public static final int EOF=-1;
+ public static final int Y=7;
+ public static final int X=6;
+
+ Rule enclosingRule;
+ Grammar grammar;
+ antlr.Token actionToken;
+ int outerAltNum = 0;
+
+ public ActionAnalysis(Grammar grammar, String ruleName, GrammarAST actionAST)
+ {
+ this(new ANTLRStringStream(actionAST.token.getText()));
+ this.grammar = grammar;
+ this.enclosingRule = grammar.getLocallyDefinedRule(ruleName);
+ this.actionToken = actionAST.token;
+ this.outerAltNum = actionAST.outerAltNum;
+ }
+
+ public void analyze() {
+ // System.out.println("###\naction="+actionToken);
+ Token t;
+ do {
+ t = nextToken();
+ } while ( t.getType()!= Token.EOF );
+ }
+
+
+ // delegates
+ // delegators
+
+ public ActionAnalysis() {;}
+ public ActionAnalysis(CharStream input) {
+ this(input, new RecognizerSharedState());
+ }
+ public ActionAnalysis(CharStream input, RecognizerSharedState state) {
+ super(input,state);
+
+ }
+ public String getGrammarFileName() { return "org/antlr/grammar/v3/ActionAnalysis.g"; }
+
+ public Token nextToken() {
+ while (true) {
+ if ( input.LA(1)==CharStream.EOF ) {
+ return Token.EOF_TOKEN;
+ }
+ state.token = null;
+ state.channel = Token.DEFAULT_CHANNEL;
+ state.tokenStartCharIndex = input.index();
+ state.tokenStartCharPositionInLine = input.getCharPositionInLine();
+ state.tokenStartLine = input.getLine();
+ state.text = null;
+ try {
+ int m = input.mark();
+ state.backtracking=1;
+ state.failed=false;
+ mTokens();
+ state.backtracking=0;
+
+ if ( state.failed ) {
+ input.rewind(m);
+ input.consume();
+ }
+ else {
+ emit();
+ return state.token;
+ }
+ }
+ catch (RecognitionException re) {
+ // shouldn't happen in backtracking mode, but...
+ reportError(re);
+ recover(re);
+ }
+ }
+ }
+
+ public void memoize(IntStream input,
+ int ruleIndex,
+ int ruleStartIndex)
+ {
+ if ( state.backtracking>1 ) super.memoize(input, ruleIndex, ruleStartIndex);
+ }
+
+ public boolean alreadyParsedRule(IntStream input, int ruleIndex) {
+ if ( state.backtracking>1 ) return super.alreadyParsedRule(input, ruleIndex);
+ return false;
+ }// $ANTLR start "X_Y"
+ public final void mX_Y() throws RecognitionException {
+ try {
+ int _type = X_Y;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ Token x=null;
+ Token y=null;
+
+ // org/antlr/grammar/v3/ActionAnalysis.g:74:5: ( '$' x= ID '.' y= ID {...}?)
+ // org/antlr/grammar/v3/ActionAnalysis.g:74:7: '$' x= ID '.' y= ID {...}?
+ {
+ match('$'); if (state.failed) return ;
+ int xStart48 = getCharIndex();
+ mID(); if (state.failed) return ;
+ x = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, xStart48, getCharIndex()-1);
+ match('.'); if (state.failed) return ;
+ int yStart54 = getCharIndex();
+ mID(); if (state.failed) return ;
+ y = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, yStart54, getCharIndex()-1);
+ if ( !((enclosingRule!=null)) ) {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ throw new FailedPredicateException(input, "X_Y", "enclosingRule!=null");
+ }
+ if ( state.backtracking==1 ) {
+
+ AttributeScope scope = null;
+ String refdRuleName = null;
+ if ( (x!=null?x.getText():null).equals(enclosingRule.name) ) {
+ // ref to enclosing rule.
+ refdRuleName = (x!=null?x.getText():null);
+ scope = enclosingRule.getLocalAttributeScope((y!=null?y.getText():null));
+ }
+ else if ( enclosingRule.getRuleLabel((x!=null?x.getText():null))!=null ) {
+ // ref to rule label
+ Grammar.LabelElementPair pair = enclosingRule.getRuleLabel((x!=null?x.getText():null));
+ pair.actionReferencesLabel = true;
+ refdRuleName = pair.referencedRuleName;
+ Rule refdRule = grammar.getRule(refdRuleName);
+ if ( refdRule!=null ) {
+ scope = refdRule.getLocalAttributeScope((y!=null?y.getText():null));
+ }
+ }
+ else if ( enclosingRule.getRuleRefsInAlt(x.getText(), outerAltNum)!=null ) {
+ // ref to rule referenced in this alt
+ refdRuleName = (x!=null?x.getText():null);
+ Rule refdRule = grammar.getRule(refdRuleName);
+ if ( refdRule!=null ) {
+ scope = refdRule.getLocalAttributeScope((y!=null?y.getText():null));
+ }
+ }
+ if ( scope!=null &&
+ (scope.isPredefinedRuleScope||scope.isPredefinedLexerRuleScope) )
+ {
+ grammar.referenceRuleLabelPredefinedAttribute(refdRuleName);
+ //System.out.println("referenceRuleLabelPredefinedAttribute for "+refdRuleName);
+ }
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "X_Y"
+
+ // $ANTLR start "X"
+ public final void mX() throws RecognitionException {
+ try {
+ int _type = X;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ Token x=null;
+
+ // org/antlr/grammar/v3/ActionAnalysis.g:111:3: ( '$' x= ID {...}?)
+ // org/antlr/grammar/v3/ActionAnalysis.g:111:5: '$' x= ID {...}?
+ {
+ match('$'); if (state.failed) return ;
+ int xStart76 = getCharIndex();
+ mID(); if (state.failed) return ;
+ x = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, xStart76, getCharIndex()-1);
+ if ( !((enclosingRule!=null && enclosingRule.getRuleLabel((x!=null?x.getText():null))!=null)) ) {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ throw new FailedPredicateException(input, "X", "enclosingRule!=null && enclosingRule.getRuleLabel($x.text)!=null");
+ }
+ if ( state.backtracking==1 ) {
+
+ Grammar.LabelElementPair pair = enclosingRule.getRuleLabel((x!=null?x.getText():null));
+ pair.actionReferencesLabel = true;
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "X"
+
+ // $ANTLR start "Y"
+ public final void mY() throws RecognitionException {
+ try {
+ int _type = Y;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ Token ID1=null;
+
+ // org/antlr/grammar/v3/ActionAnalysis.g:119:3: ( '$' ID {...}?)
+ // org/antlr/grammar/v3/ActionAnalysis.g:119:5: '$' ID {...}?
+ {
+ match('$'); if (state.failed) return ;
+ int ID1Start97 = getCharIndex();
+ mID(); if (state.failed) return ;
+ ID1 = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, ID1Start97, getCharIndex()-1);
+ if ( !((enclosingRule!=null && enclosingRule.getLocalAttributeScope((ID1!=null?ID1.getText():null))!=null)) ) {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ throw new FailedPredicateException(input, "Y", "enclosingRule!=null && enclosingRule.getLocalAttributeScope($ID.text)!=null");
+ }
+ if ( state.backtracking==1 ) {
+
+ AttributeScope scope = enclosingRule.getLocalAttributeScope((ID1!=null?ID1.getText():null));
+ if ( scope!=null &&
+ (scope.isPredefinedRuleScope||scope.isPredefinedLexerRuleScope) )
+ {
+ grammar.referenceRuleLabelPredefinedAttribute(enclosingRule.name);
+ //System.out.println("referenceRuleLabelPredefinedAttribute for "+(ID1!=null?ID1.getText():null));
+ }
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "Y"
+
+ // $ANTLR start "ID"
+ public final void mID() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ActionAnalysis.g:132:5: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* )
+ // org/antlr/grammar/v3/ActionAnalysis.g:132:9: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
+ {
+ if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
+ input.consume();
+ state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ // org/antlr/grammar/v3/ActionAnalysis.g:132:33: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
+ loop1:
+ do {
+ int alt1=2;
+ int LA1_0 = input.LA(1);
+
+ if ( ((LA1_0>='0' && LA1_0<='9')||(LA1_0>='A' && LA1_0<='Z')||LA1_0=='_'||(LA1_0>='a' && LA1_0<='z')) ) {
+ alt1=1;
+ }
+
+
+ switch (alt1) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionAnalysis.g:
+ {
+ if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
+ input.consume();
+ state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop1;
+ }
+ } while (true);
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "ID"
+
+ public void mTokens() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionAnalysis.g:1:39: ( X_Y | X | Y )
+ int alt2=3;
+ int LA2_0 = input.LA(1);
+
+ if ( (LA2_0=='$') ) {
+ int LA2_1 = input.LA(2);
+
+ if ( (synpred1_ActionAnalysis()) ) {
+ alt2=1;
+ }
+ else if ( (synpred2_ActionAnalysis()) ) {
+ alt2=2;
+ }
+ else if ( (true) ) {
+ alt2=3;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 2, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 2, 0, input);
+
+ throw nvae;
+ }
+ switch (alt2) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionAnalysis.g:1:41: X_Y
+ {
+ mX_Y(); if (state.failed) return ;
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ActionAnalysis.g:1:45: X
+ {
+ mX(); if (state.failed) return ;
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ActionAnalysis.g:1:47: Y
+ {
+ mY(); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ }
+
+ // $ANTLR start synpred1_ActionAnalysis
+ public final void synpred1_ActionAnalysis_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionAnalysis.g:1:41: ( X_Y )
+ // org/antlr/grammar/v3/ActionAnalysis.g:1:41: X_Y
+ {
+ mX_Y(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred1_ActionAnalysis
+
+ // $ANTLR start synpred2_ActionAnalysis
+ public final void synpred2_ActionAnalysis_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionAnalysis.g:1:45: ( X )
+ // org/antlr/grammar/v3/ActionAnalysis.g:1:45: X
+ {
+ mX(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred2_ActionAnalysis
+
+ public final boolean synpred2_ActionAnalysis() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred2_ActionAnalysis_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred1_ActionAnalysis() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred1_ActionAnalysis_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+
+
+
+
+}
\ No newline at end of file
diff --git a/debian/generated-sources/antlr3/org/antlr/grammar/v3/ActionTranslator.java b/debian/generated-sources/antlr3/org/antlr/grammar/v3/ActionTranslator.java
new file mode 100644
index 0000000..272f157
--- /dev/null
+++ b/debian/generated-sources/antlr3/org/antlr/grammar/v3/ActionTranslator.java
@@ -0,0 +1,3468 @@
+// $ANTLR 3.1.3 Mar 17, 2009 19:23:44 org/antlr/grammar/v3/ActionTranslator.g 2010-05-13 00:10:15
+
+package org.antlr.grammar.v3;
+import org.antlr.stringtemplate.StringTemplate;
+import org.antlr.runtime.*;
+import org.antlr.tool.*;
+import org.antlr.codegen.*;
+
+import org.antlr.runtime.*;
+import java.util.List;
+import java.util.ArrayList;
+import org.antlr.grammar.v2.ANTLRParser;
+
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+public class ActionTranslator extends Lexer {
+ public static final int INDIRECT_TEMPLATE_INSTANCE=28;
+ public static final int RULE_SCOPE_ATTR=12;
+ public static final int ESC=32;
+ public static final int SET_RULE_SCOPE_ATTR=11;
+ public static final int DYNAMIC_NEGATIVE_INDEXED_SCOPE_ATTR=22;
+ public static final int SET_ATTRIBUTE=30;
+ public static final int ERROR_SCOPED_XY=20;
+ public static final int INT=37;
+ public static final int TEMPLATE_EXPR=31;
+ public static final int ERROR_XY=33;
+ public static final int LOCAL_ATTR=17;
+ public static final int TEXT=36;
+ public static final int ISOLATED_TOKEN_REF=14;
+ public static final int ID=4;
+ public static final int TOKEN_SCOPE_ATTR=10;
+ public static final int EOF=-1;
+ public static final int SET_TOKEN_SCOPE_ATTR=9;
+ public static final int ACTION=27;
+ public static final int UNKNOWN_SYNTAX=35;
+ public static final int WS=5;
+ public static final int ARG=25;
+ public static final int TEMPLATE_INSTANCE=26;
+ public static final int ISOLATED_LEXER_RULE_REF=15;
+ public static final int SET_EXPR_ATTRIBUTE=29;
+ public static final int ATTR_VALUE_EXPR=6;
+ public static final int SET_ENCLOSING_RULE_SCOPE_ATTR=7;
+ public static final int SET_LOCAL_ATTR=16;
+ public static final int ENCLOSING_RULE_SCOPE_ATTR=8;
+ public static final int SET_DYNAMIC_SCOPE_ATTR=18;
+ public static final int SCOPE_INDEX_EXPR=21;
+ public static final int ISOLATED_DYNAMIC_SCOPE=24;
+ public static final int LABEL_REF=13;
+ public static final int DYNAMIC_SCOPE_ATTR=19;
+ public static final int ERROR_X=34;
+ public static final int DYNAMIC_ABSOLUTE_INDEXED_SCOPE_ATTR=23;
+
+ public List chunks = new ArrayList();
+ Rule enclosingRule;
+ int outerAltNum;
+ Grammar grammar;
+ CodeGenerator generator;
+ antlr.Token actionToken;
+
+ public ActionTranslator(CodeGenerator generator,
+ String ruleName,
+ GrammarAST actionAST)
+ {
+ this(new ANTLRStringStream(actionAST.token.getText()));
+ this.generator = generator;
+ this.grammar = generator.grammar;
+ this.enclosingRule = grammar.getLocallyDefinedRule(ruleName);
+ this.actionToken = actionAST.token;
+ this.outerAltNum = actionAST.outerAltNum;
+ }
+
+ public ActionTranslator(CodeGenerator generator,
+ String ruleName,
+ antlr.Token actionToken,
+ int outerAltNum)
+ {
+ this(new ANTLRStringStream(actionToken.getText()));
+ this.generator = generator;
+ grammar = generator.grammar;
+ this.enclosingRule = grammar.getRule(ruleName);
+ this.actionToken = actionToken;
+ this.outerAltNum = outerAltNum;
+ }
+
+ /** Return a list of strings and StringTemplate objects that
+ * represent the translated action.
+ */
+ public List translateToChunks() {
+ // System.out.println("###\naction="+action);
+ Token t;
+ do {
+ t = nextToken();
+ } while ( t.getType()!= Token.EOF );
+ return chunks;
+ }
+
+ public String translate() {
+ List theChunks = translateToChunks();
+ //System.out.println("chunks="+a.chunks);
+ StringBuffer buf = new StringBuffer();
+ for (int i = 0; i < theChunks.size(); i++) {
+ Object o = (Object) theChunks.get(i);
+ buf.append(o);
+ }
+ //System.out.println("translated: "+buf.toString());
+ return buf.toString();
+ }
+
+ public List translateAction(String action) {
+ String rname = null;
+ if ( enclosingRule!=null ) {
+ rname = enclosingRule.name;
+ }
+ ActionTranslator translator =
+ new ActionTranslator(generator,
+ rname,
+ new antlr.CommonToken(ANTLRParser.ACTION,action),outerAltNum);
+ return translator.translateToChunks();
+ }
+
+ public boolean isTokenRefInAlt(String id) {
+ return enclosingRule.getTokenRefsInAlt(id, outerAltNum)!=null;
+ }
+ public boolean isRuleRefInAlt(String id) {
+ return enclosingRule.getRuleRefsInAlt(id, outerAltNum)!=null;
+ }
+ public Grammar.LabelElementPair getElementLabel(String id) {
+ return enclosingRule.getLabel(id);
+ }
+
+ public void checkElementRefUniqueness(String ref, boolean isToken) {
+ List refs = null;
+ if ( isToken ) {
+ refs = enclosingRule.getTokenRefsInAlt(ref, outerAltNum);
+ }
+ else {
+ refs = enclosingRule.getRuleRefsInAlt(ref, outerAltNum);
+ }
+ if ( refs!=null && refs.size()>1 ) {
+ ErrorManager.grammarError(ErrorManager.MSG_NONUNIQUE_REF,
+ grammar,
+ actionToken,
+ ref);
+ }
+ }
+
+ /** For $rulelabel.name, return the Attribute found for name. It
+ * will be a predefined property or a return value.
+ */
+ public Attribute getRuleLabelAttribute(String ruleName, String attrName) {
+ Rule r = grammar.getRule(ruleName);
+ AttributeScope scope = r.getLocalAttributeScope(attrName);
+ if ( scope!=null && !scope.isParameterScope ) {
+ return scope.getAttribute(attrName);
+ }
+ return null;
+ }
+
+ AttributeScope resolveDynamicScope(String scopeName) {
+ if ( grammar.getGlobalScope(scopeName)!=null ) {
+ return grammar.getGlobalScope(scopeName);
+ }
+ Rule scopeRule = grammar.getRule(scopeName);
+ if ( scopeRule!=null ) {
+ return scopeRule.ruleScope;
+ }
+ return null; // not a valid dynamic scope
+ }
+
+ protected StringTemplate template(String name) {
+ StringTemplate st = generator.getTemplates().getInstanceOf(name);
+ chunks.add(st);
+ return st;
+ }
+
+
+
+
+ // delegates
+ // delegators
+
+ public ActionTranslator() {;}
+ public ActionTranslator(CharStream input) {
+ this(input, new RecognizerSharedState());
+ }
+ public ActionTranslator(CharStream input, RecognizerSharedState state) {
+ super(input,state);
+
+ }
+ public String getGrammarFileName() { return "org/antlr/grammar/v3/ActionTranslator.g"; }
+
+ public Token nextToken() {
+ while (true) {
+ if ( input.LA(1)==CharStream.EOF ) {
+ return Token.EOF_TOKEN;
+ }
+ state.token = null;
+ state.channel = Token.DEFAULT_CHANNEL;
+ state.tokenStartCharIndex = input.index();
+ state.tokenStartCharPositionInLine = input.getCharPositionInLine();
+ state.tokenStartLine = input.getLine();
+ state.text = null;
+ try {
+ int m = input.mark();
+ state.backtracking=1;
+ state.failed=false;
+ mTokens();
+ state.backtracking=0;
+
+ if ( state.failed ) {
+ input.rewind(m);
+ input.consume();
+ }
+ else {
+ emit();
+ return state.token;
+ }
+ }
+ catch (RecognitionException re) {
+ // shouldn't happen in backtracking mode, but...
+ reportError(re);
+ recover(re);
+ }
+ }
+ }
+
+ public void memoize(IntStream input,
+ int ruleIndex,
+ int ruleStartIndex)
+ {
+ if ( state.backtracking>1 ) super.memoize(input, ruleIndex, ruleStartIndex);
+ }
+
+ public boolean alreadyParsedRule(IntStream input, int ruleIndex) {
+ if ( state.backtracking>1 ) return super.alreadyParsedRule(input, ruleIndex);
+ return false;
+ }// $ANTLR start "SET_ENCLOSING_RULE_SCOPE_ATTR"
+ public final void mSET_ENCLOSING_RULE_SCOPE_ATTR() throws RecognitionException {
+ try {
+ int _type = SET_ENCLOSING_RULE_SCOPE_ATTR;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ Token x=null;
+ Token y=null;
+ Token expr=null;
+
+ // org/antlr/grammar/v3/ActionTranslator.g:184:2: ( '$' x= ID '.' y= ID ( WS )? '=' expr= ATTR_VALUE_EXPR ';' {...}?)
+ // org/antlr/grammar/v3/ActionTranslator.g:184:4: '$' x= ID '.' y= ID ( WS )? '=' expr= ATTR_VALUE_EXPR ';' {...}?
+ {
+ match('$'); if (state.failed) return ;
+ int xStart50 = getCharIndex();
+ mID(); if (state.failed) return ;
+ x = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, xStart50, getCharIndex()-1);
+ match('.'); if (state.failed) return ;
+ int yStart56 = getCharIndex();
+ mID(); if (state.failed) return ;
+ y = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, yStart56, getCharIndex()-1);
+ // org/antlr/grammar/v3/ActionTranslator.g:184:22: ( WS )?
+ int alt1=2;
+ int LA1_0 = input.LA(1);
+
+ if ( ((LA1_0>='\t' && LA1_0<='\n')||LA1_0=='\r'||LA1_0==' ') ) {
+ alt1=1;
+ }
+ switch (alt1) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:184:22: WS
+ {
+ mWS(); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ match('='); if (state.failed) return ;
+ int exprStart65 = getCharIndex();
+ mATTR_VALUE_EXPR(); if (state.failed) return ;
+ expr = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, exprStart65, getCharIndex()-1);
+ match(';'); if (state.failed) return ;
+ if ( !((enclosingRule!=null &&
+ (x!=null?x.getText():null).equals(enclosingRule.name) &&
+ enclosingRule.getLocalAttributeScope((y!=null?y.getText():null))!=null)) ) {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ throw new FailedPredicateException(input, "SET_ENCLOSING_RULE_SCOPE_ATTR", "enclosingRule!=null &&\n\t $x.text.equals(enclosingRule.name) &&\n\t enclosingRule.getLocalAttributeScope($y.text)!=null");
+ }
+ if ( state.backtracking==1 ) {
+
+ StringTemplate st = null;
+ AttributeScope scope = enclosingRule.getLocalAttributeScope((y!=null?y.getText():null));
+ if ( scope.isPredefinedRuleScope ) {
+ if ( (y!=null?y.getText():null).equals("st") || (y!=null?y.getText():null).equals("tree") ) {
+ st = template("ruleSetPropertyRef_"+(y!=null?y.getText():null));
+ grammar.referenceRuleLabelPredefinedAttribute((x!=null?x.getText():null));
+ st.setAttribute("scope", (x!=null?x.getText():null));
+ st.setAttribute("attr", (y!=null?y.getText():null));
+ st.setAttribute("expr", translateAction((expr!=null?expr.getText():null)));
+ } else {
+ ErrorManager.grammarError(ErrorManager.MSG_WRITE_TO_READONLY_ATTR,
+ grammar,
+ actionToken,
+ (x!=null?x.getText():null),
+ (y!=null?y.getText():null));
+ }
+ }
+ else if ( scope.isPredefinedLexerRuleScope ) {
+ // this is a better message to emit than the previous one...
+ ErrorManager.grammarError(ErrorManager.MSG_WRITE_TO_READONLY_ATTR,
+ grammar,
+ actionToken,
+ (x!=null?x.getText():null),
+ (y!=null?y.getText():null));
+ }
+ else if ( scope.isParameterScope ) {
+ st = template("parameterSetAttributeRef");
+ st.setAttribute("attr", scope.getAttribute((y!=null?y.getText():null)));
+ st.setAttribute("expr", translateAction((expr!=null?expr.getText():null)));
+ }
+ else { // must be return value
+ st = template("returnSetAttributeRef");
+ st.setAttribute("ruleDescriptor", enclosingRule);
+ st.setAttribute("attr", scope.getAttribute((y!=null?y.getText():null)));
+ st.setAttribute("expr", translateAction((expr!=null?expr.getText():null)));
+ }
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "SET_ENCLOSING_RULE_SCOPE_ATTR"
+
+ // $ANTLR start "ENCLOSING_RULE_SCOPE_ATTR"
+ public final void mENCLOSING_RULE_SCOPE_ATTR() throws RecognitionException {
+ try {
+ int _type = ENCLOSING_RULE_SCOPE_ATTR;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ Token x=null;
+ Token y=null;
+
+ // org/antlr/grammar/v3/ActionTranslator.g:229:2: ( '$' x= ID '.' y= ID {...}?)
+ // org/antlr/grammar/v3/ActionTranslator.g:229:4: '$' x= ID '.' y= ID {...}?
+ {
+ match('$'); if (state.failed) return ;
+ int xStart97 = getCharIndex();
+ mID(); if (state.failed) return ;
+ x = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, xStart97, getCharIndex()-1);
+ match('.'); if (state.failed) return ;
+ int yStart103 = getCharIndex();
+ mID(); if (state.failed) return ;
+ y = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, yStart103, getCharIndex()-1);
+ if ( !((enclosingRule!=null &&
+ (x!=null?x.getText():null).equals(enclosingRule.name) &&
+ enclosingRule.getLocalAttributeScope((y!=null?y.getText():null))!=null)) ) {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ throw new FailedPredicateException(input, "ENCLOSING_RULE_SCOPE_ATTR", "enclosingRule!=null &&\n\t $x.text.equals(enclosingRule.name) &&\n\t enclosingRule.getLocalAttributeScope($y.text)!=null");
+ }
+ if ( state.backtracking==1 ) {
+
+ if ( isRuleRefInAlt((x!=null?x.getText():null)) ) {
+ ErrorManager.grammarError(ErrorManager.MSG_RULE_REF_AMBIG_WITH_RULE_IN_ALT,
+ grammar,
+ actionToken,
+ (x!=null?x.getText():null));
+ }
+ StringTemplate st = null;
+ AttributeScope scope = enclosingRule.getLocalAttributeScope((y!=null?y.getText():null));
+ if ( scope.isPredefinedRuleScope ) {
+ st = template("rulePropertyRef_"+(y!=null?y.getText():null));
+ grammar.referenceRuleLabelPredefinedAttribute((x!=null?x.getText():null));
+ st.setAttribute("scope", (x!=null?x.getText():null));
+ st.setAttribute("attr", (y!=null?y.getText():null));
+ }
+ else if ( scope.isPredefinedLexerRuleScope ) {
+ // perhaps not the most precise error message to use, but...
+ ErrorManager.grammarError(ErrorManager.MSG_RULE_HAS_NO_ARGS,
+ grammar,
+ actionToken,
+ (x!=null?x.getText():null));
+ }
+ else if ( scope.isParameterScope ) {
+ st = template("parameterAttributeRef");
+ st.setAttribute("attr", scope.getAttribute((y!=null?y.getText():null)));
+ }
+ else { // must be return value
+ st = template("returnAttributeRef");
+ st.setAttribute("ruleDescriptor", enclosingRule);
+ st.setAttribute("attr", scope.getAttribute((y!=null?y.getText():null)));
+ }
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "ENCLOSING_RULE_SCOPE_ATTR"
+
+ // $ANTLR start "SET_TOKEN_SCOPE_ATTR"
+ public final void mSET_TOKEN_SCOPE_ATTR() throws RecognitionException {
+ try {
+ int _type = SET_TOKEN_SCOPE_ATTR;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ Token x=null;
+ Token y=null;
+
+ // org/antlr/grammar/v3/ActionTranslator.g:269:2: ( '$' x= ID '.' y= ID ( WS )? '=' {...}?)
+ // org/antlr/grammar/v3/ActionTranslator.g:269:4: '$' x= ID '.' y= ID ( WS )? '=' {...}?
+ {
+ match('$'); if (state.failed) return ;
+ int xStart129 = getCharIndex();
+ mID(); if (state.failed) return ;
+ x = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, xStart129, getCharIndex()-1);
+ match('.'); if (state.failed) return ;
+ int yStart135 = getCharIndex();
+ mID(); if (state.failed) return ;
+ y = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, yStart135, getCharIndex()-1);
+ // org/antlr/grammar/v3/ActionTranslator.g:269:22: ( WS )?
+ int alt2=2;
+ int LA2_0 = input.LA(1);
+
+ if ( ((LA2_0>='\t' && LA2_0<='\n')||LA2_0=='\r'||LA2_0==' ') ) {
+ alt2=1;
+ }
+ switch (alt2) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:269:22: WS
+ {
+ mWS(); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ match('='); if (state.failed) return ;
+ if ( !((enclosingRule!=null && input.LA(1)!='=' &&
+ (enclosingRule.getTokenLabel((x!=null?x.getText():null))!=null||
+ isTokenRefInAlt((x!=null?x.getText():null))) &&
+ AttributeScope.tokenScope.getAttribute((y!=null?y.getText():null))!=null)) ) {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ throw new FailedPredicateException(input, "SET_TOKEN_SCOPE_ATTR", "enclosingRule!=null && input.LA(1)!='=' &&\n\t (enclosingRule.getTokenLabel($x.text)!=null||\n\t isTokenRefInAlt($x.text)) &&\n\t AttributeScope.tokenScope.getAttribute($y.text)!=null");
+ }
+ if ( state.backtracking==1 ) {
+
+ ErrorManager.grammarError(ErrorManager.MSG_WRITE_TO_READONLY_ATTR,
+ grammar,
+ actionToken,
+ (x!=null?x.getText():null),
+ (y!=null?y.getText():null));
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "SET_TOKEN_SCOPE_ATTR"
+
+ // $ANTLR start "TOKEN_SCOPE_ATTR"
+ public final void mTOKEN_SCOPE_ATTR() throws RecognitionException {
+ try {
+ int _type = TOKEN_SCOPE_ATTR;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ Token x=null;
+ Token y=null;
+
+ // org/antlr/grammar/v3/ActionTranslator.g:288:2: ( '$' x= ID '.' y= ID {...}?)
+ // org/antlr/grammar/v3/ActionTranslator.g:288:4: '$' x= ID '.' y= ID {...}?
+ {
+ match('$'); if (state.failed) return ;
+ int xStart174 = getCharIndex();
+ mID(); if (state.failed) return ;
+ x = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, xStart174, getCharIndex()-1);
+ match('.'); if (state.failed) return ;
+ int yStart180 = getCharIndex();
+ mID(); if (state.failed) return ;
+ y = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, yStart180, getCharIndex()-1);
+ if ( !((enclosingRule!=null &&
+ (enclosingRule.getTokenLabel((x!=null?x.getText():null))!=null||
+ isTokenRefInAlt((x!=null?x.getText():null))) &&
+ AttributeScope.tokenScope.getAttribute((y!=null?y.getText():null))!=null &&
+ (grammar.type!=Grammar.LEXER ||
+ getElementLabel((x!=null?x.getText():null)).elementRef.token.getType()==ANTLRParser.TOKEN_REF ||
+ getElementLabel((x!=null?x.getText():null)).elementRef.token.getType()==ANTLRParser.STRING_LITERAL))) ) {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ throw new FailedPredicateException(input, "TOKEN_SCOPE_ATTR", "enclosingRule!=null &&\n\t (enclosingRule.getTokenLabel($x.text)!=null||\n\t isTokenRefInAlt($x.text)) &&\n\t AttributeScope.tokenScope.getAttribute($y.text)!=null &&\n\t (grammar.type!=Grammar.LEXER ||\n\t getElementLabel($x.text).elementRef.token.getType()==ANTLRParser.TOKEN_REF ||\n\t [...]
+ }
+ if ( state.backtracking==1 ) {
+
+ String label = (x!=null?x.getText():null);
+ if ( enclosingRule.getTokenLabel((x!=null?x.getText():null))==null ) {
+ // $tokenref.attr gotta get old label or compute new one
+ checkElementRefUniqueness((x!=null?x.getText():null), true);
+ label = enclosingRule.getElementLabel((x!=null?x.getText():null), outerAltNum, generator);
+ if ( label==null ) {
+ ErrorManager.grammarError(ErrorManager.MSG_FORWARD_ELEMENT_REF,
+ grammar,
+ actionToken,
+ "$"+(x!=null?x.getText():null)+"."+(y!=null?y.getText():null));
+ label = (x!=null?x.getText():null);
+ }
+ }
+ StringTemplate st = template("tokenLabelPropertyRef_"+(y!=null?y.getText():null));
+ st.setAttribute("scope", label);
+ st.setAttribute("attr", AttributeScope.tokenScope.getAttribute((y!=null?y.getText():null)));
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "TOKEN_SCOPE_ATTR"
+
+ // $ANTLR start "SET_RULE_SCOPE_ATTR"
+ public final void mSET_RULE_SCOPE_ATTR() throws RecognitionException {
+ try {
+ int _type = SET_RULE_SCOPE_ATTR;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ Token x=null;
+ Token y=null;
+
+
+ Grammar.LabelElementPair pair=null;
+ String refdRuleName=null;
+
+ // org/antlr/grammar/v3/ActionTranslator.g:326:2: ( '$' x= ID '.' y= ID ( WS )? '=' {...}?{...}?)
+ // org/antlr/grammar/v3/ActionTranslator.g:326:4: '$' x= ID '.' y= ID ( WS )? '=' {...}?{...}?
+ {
+ match('$'); if (state.failed) return ;
+ int xStart211 = getCharIndex();
+ mID(); if (state.failed) return ;
+ x = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, xStart211, getCharIndex()-1);
+ match('.'); if (state.failed) return ;
+ int yStart217 = getCharIndex();
+ mID(); if (state.failed) return ;
+ y = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, yStart217, getCharIndex()-1);
+ // org/antlr/grammar/v3/ActionTranslator.g:326:22: ( WS )?
+ int alt3=2;
+ int LA3_0 = input.LA(1);
+
+ if ( ((LA3_0>='\t' && LA3_0<='\n')||LA3_0=='\r'||LA3_0==' ') ) {
+ alt3=1;
+ }
+ switch (alt3) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:326:22: WS
+ {
+ mWS(); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ match('='); if (state.failed) return ;
+ if ( !((enclosingRule!=null && input.LA(1)!='=')) ) {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ throw new FailedPredicateException(input, "SET_RULE_SCOPE_ATTR", "enclosingRule!=null && input.LA(1)!='='");
+ }
+ if ( state.backtracking==1 ) {
+
+ pair = enclosingRule.getRuleLabel((x!=null?x.getText():null));
+ refdRuleName = (x!=null?x.getText():null);
+ if ( pair!=null ) {
+ refdRuleName = pair.referencedRuleName;
+ }
+
+ }
+ if ( !(((enclosingRule.getRuleLabel((x!=null?x.getText():null))!=null || isRuleRefInAlt((x!=null?x.getText():null))) &&
+ getRuleLabelAttribute(enclosingRule.getRuleLabel((x!=null?x.getText():null))!=null?enclosingRule.getRuleLabel((x!=null?x.getText():null)).referencedRuleName:(x!=null?x.getText():null),(y!=null?y.getText():null))!=null)) ) {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ throw new FailedPredicateException(input, "SET_RULE_SCOPE_ATTR", "(enclosingRule.getRuleLabel($x.text)!=null || isRuleRefInAlt($x.text)) &&\n\t getRuleLabelAttribute(enclosingRule.getRuleLabel($x.text)!=null?enclosingRule.getRuleLabel($x.text).referencedRuleName:$x.text,$y.text)!=null");
+ }
+ if ( state.backtracking==1 ) {
+
+ ErrorManager.grammarError(ErrorManager.MSG_WRITE_TO_READONLY_ATTR,
+ grammar,
+ actionToken,
+ (x!=null?x.getText():null),
+ (y!=null?y.getText():null));
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "SET_RULE_SCOPE_ATTR"
+
+ // $ANTLR start "RULE_SCOPE_ATTR"
+ public final void mRULE_SCOPE_ATTR() throws RecognitionException {
+ try {
+ int _type = RULE_SCOPE_ATTR;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ Token x=null;
+ Token y=null;
+
+
+ Grammar.LabelElementPair pair=null;
+ String refdRuleName=null;
+
+ // org/antlr/grammar/v3/ActionTranslator.g:355:2: ( '$' x= ID '.' y= ID {...}?{...}?)
+ // org/antlr/grammar/v3/ActionTranslator.g:355:4: '$' x= ID '.' y= ID {...}?{...}?
+ {
+ match('$'); if (state.failed) return ;
+ int xStart270 = getCharIndex();
+ mID(); if (state.failed) return ;
+ x = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, xStart270, getCharIndex()-1);
+ match('.'); if (state.failed) return ;
+ int yStart276 = getCharIndex();
+ mID(); if (state.failed) return ;
+ y = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, yStart276, getCharIndex()-1);
+ if ( !((enclosingRule!=null)) ) {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ throw new FailedPredicateException(input, "RULE_SCOPE_ATTR", "enclosingRule!=null");
+ }
+ if ( state.backtracking==1 ) {
+
+ pair = enclosingRule.getRuleLabel((x!=null?x.getText():null));
+ refdRuleName = (x!=null?x.getText():null);
+ if ( pair!=null ) {
+ refdRuleName = pair.referencedRuleName;
+ }
+
+ }
+ if ( !(((enclosingRule.getRuleLabel((x!=null?x.getText():null))!=null || isRuleRefInAlt((x!=null?x.getText():null))) &&
+ getRuleLabelAttribute(enclosingRule.getRuleLabel((x!=null?x.getText():null))!=null?enclosingRule.getRuleLabel((x!=null?x.getText():null)).referencedRuleName:(x!=null?x.getText():null),(y!=null?y.getText():null))!=null)) ) {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ throw new FailedPredicateException(input, "RULE_SCOPE_ATTR", "(enclosingRule.getRuleLabel($x.text)!=null || isRuleRefInAlt($x.text)) &&\n\t getRuleLabelAttribute(enclosingRule.getRuleLabel($x.text)!=null?enclosingRule.getRuleLabel($x.text).referencedRuleName:$x.text,$y.text)!=null");
+ }
+ if ( state.backtracking==1 ) {
+
+ String label = (x!=null?x.getText():null);
+ if ( pair==null ) {
+ // $ruleref.attr gotta get old label or compute new one
+ checkElementRefUniqueness((x!=null?x.getText():null), false);
+ label = enclosingRule.getElementLabel((x!=null?x.getText():null), outerAltNum, generator);
+ if ( label==null ) {
+ ErrorManager.grammarError(ErrorManager.MSG_FORWARD_ELEMENT_REF,
+ grammar,
+ actionToken,
+ "$"+(x!=null?x.getText():null)+"."+(y!=null?y.getText():null));
+ label = (x!=null?x.getText():null);
+ }
+ }
+ StringTemplate st;
+ Rule refdRule = grammar.getRule(refdRuleName);
+ AttributeScope scope = refdRule.getLocalAttributeScope((y!=null?y.getText():null));
+ if ( scope.isPredefinedRuleScope ) {
+ st = template("ruleLabelPropertyRef_"+(y!=null?y.getText():null));
+ grammar.referenceRuleLabelPredefinedAttribute(refdRuleName);
+ st.setAttribute("scope", label);
+ st.setAttribute("attr", (y!=null?y.getText():null));
+ }
+ else if ( scope.isPredefinedLexerRuleScope ) {
+ st = template("lexerRuleLabelPropertyRef_"+(y!=null?y.getText():null));
+ grammar.referenceRuleLabelPredefinedAttribute(refdRuleName);
+ st.setAttribute("scope", label);
+ st.setAttribute("attr", (y!=null?y.getText():null));
+ }
+ else if ( scope.isParameterScope ) {
+ // TODO: error!
+ }
+ else {
+ st = template("ruleLabelRef");
+ st.setAttribute("referencedRule", refdRule);
+ st.setAttribute("scope", label);
+ st.setAttribute("attr", scope.getAttribute((y!=null?y.getText():null)));
+ }
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_SCOPE_ATTR"
+
+ // $ANTLR start "LABEL_REF"
+ public final void mLABEL_REF() throws RecognitionException {
+ try {
+ int _type = LABEL_REF;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ Token ID1=null;
+
+ // org/antlr/grammar/v3/ActionTranslator.g:413:2: ( '$' ID {...}?)
+ // org/antlr/grammar/v3/ActionTranslator.g:413:4: '$' ID {...}?
+ {
+ match('$'); if (state.failed) return ;
+ int ID1Start318 = getCharIndex();
+ mID(); if (state.failed) return ;
+ ID1 = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, ID1Start318, getCharIndex()-1);
+ if ( !((enclosingRule!=null &&
+ getElementLabel((ID1!=null?ID1.getText():null))!=null &&
+ enclosingRule.getRuleLabel((ID1!=null?ID1.getText():null))==null)) ) {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ throw new FailedPredicateException(input, "LABEL_REF", "enclosingRule!=null &&\n\t getElementLabel($ID.text)!=null &&\n\t\t enclosingRule.getRuleLabel($ID.text)==null");
+ }
+ if ( state.backtracking==1 ) {
+
+ StringTemplate st;
+ Grammar.LabelElementPair pair = getElementLabel((ID1!=null?ID1.getText():null));
+ if ( pair.type==Grammar.RULE_LIST_LABEL ||
+ pair.type==Grammar.TOKEN_LIST_LABEL ||
+ pair.type==Grammar.WILDCARD_TREE_LIST_LABEL )
+ {
+ st = template("listLabelRef");
+ }
+ else {
+ st = template("tokenLabelRef");
+ }
+ st.setAttribute("label", (ID1!=null?ID1.getText():null));
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "LABEL_REF"
+
+ // $ANTLR start "ISOLATED_TOKEN_REF"
+ public final void mISOLATED_TOKEN_REF() throws RecognitionException {
+ try {
+ int _type = ISOLATED_TOKEN_REF;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ Token ID2=null;
+
+ // org/antlr/grammar/v3/ActionTranslator.g:435:2: ( '$' ID {...}?)
+ // org/antlr/grammar/v3/ActionTranslator.g:435:4: '$' ID {...}?
+ {
+ match('$'); if (state.failed) return ;
+ int ID2Start342 = getCharIndex();
+ mID(); if (state.failed) return ;
+ ID2 = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, ID2Start342, getCharIndex()-1);
+ if ( !((grammar.type!=Grammar.LEXER && enclosingRule!=null && isTokenRefInAlt((ID2!=null?ID2.getText():null)))) ) {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ throw new FailedPredicateException(input, "ISOLATED_TOKEN_REF", "grammar.type!=Grammar.LEXER && enclosingRule!=null && isTokenRefInAlt($ID.text)");
+ }
+ if ( state.backtracking==1 ) {
+
+ String label = enclosingRule.getElementLabel((ID2!=null?ID2.getText():null), outerAltNum, generator);
+ checkElementRefUniqueness((ID2!=null?ID2.getText():null), true);
+ if ( label==null ) {
+ ErrorManager.grammarError(ErrorManager.MSG_FORWARD_ELEMENT_REF,
+ grammar,
+ actionToken,
+ (ID2!=null?ID2.getText():null));
+ }
+ else {
+ StringTemplate st = template("tokenLabelRef");
+ st.setAttribute("label", label);
+ }
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "ISOLATED_TOKEN_REF"
+
+ // $ANTLR start "ISOLATED_LEXER_RULE_REF"
+ public final void mISOLATED_LEXER_RULE_REF() throws RecognitionException {
+ try {
+ int _type = ISOLATED_LEXER_RULE_REF;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ Token ID3=null;
+
+ // org/antlr/grammar/v3/ActionTranslator.g:455:2: ( '$' ID {...}?)
+ // org/antlr/grammar/v3/ActionTranslator.g:455:4: '$' ID {...}?
+ {
+ match('$'); if (state.failed) return ;
+ int ID3Start366 = getCharIndex();
+ mID(); if (state.failed) return ;
+ ID3 = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, ID3Start366, getCharIndex()-1);
+ if ( !((grammar.type==Grammar.LEXER &&
+ enclosingRule!=null &&
+ isRuleRefInAlt((ID3!=null?ID3.getText():null)))) ) {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ throw new FailedPredicateException(input, "ISOLATED_LEXER_RULE_REF", "grammar.type==Grammar.LEXER &&\n\t enclosingRule!=null &&\n\t isRuleRefInAlt($ID.text)");
+ }
+ if ( state.backtracking==1 ) {
+
+ String label = enclosingRule.getElementLabel((ID3!=null?ID3.getText():null), outerAltNum, generator);
+ checkElementRefUniqueness((ID3!=null?ID3.getText():null), false);
+ if ( label==null ) {
+ ErrorManager.grammarError(ErrorManager.MSG_FORWARD_ELEMENT_REF,
+ grammar,
+ actionToken,
+ (ID3!=null?ID3.getText():null));
+ }
+ else {
+ StringTemplate st = template("lexerRuleLabel");
+ st.setAttribute("label", label);
+ }
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "ISOLATED_LEXER_RULE_REF"
+
+ // $ANTLR start "SET_LOCAL_ATTR"
+ public final void mSET_LOCAL_ATTR() throws RecognitionException {
+ try {
+ int _type = SET_LOCAL_ATTR;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ Token expr=null;
+ Token ID4=null;
+
+ // org/antlr/grammar/v3/ActionTranslator.g:487:2: ( '$' ID ( WS )? '=' expr= ATTR_VALUE_EXPR ';' {...}?)
+ // org/antlr/grammar/v3/ActionTranslator.g:487:4: '$' ID ( WS )? '=' expr= ATTR_VALUE_EXPR ';' {...}?
+ {
+ match('$'); if (state.failed) return ;
+ int ID4Start390 = getCharIndex();
+ mID(); if (state.failed) return ;
+ ID4 = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, ID4Start390, getCharIndex()-1);
+ // org/antlr/grammar/v3/ActionTranslator.g:487:11: ( WS )?
+ int alt4=2;
+ int LA4_0 = input.LA(1);
+
+ if ( ((LA4_0>='\t' && LA4_0<='\n')||LA4_0=='\r'||LA4_0==' ') ) {
+ alt4=1;
+ }
+ switch (alt4) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:487:11: WS
+ {
+ mWS(); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ match('='); if (state.failed) return ;
+ int exprStart399 = getCharIndex();
+ mATTR_VALUE_EXPR(); if (state.failed) return ;
+ expr = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, exprStart399, getCharIndex()-1);
+ match(';'); if (state.failed) return ;
+ if ( !((enclosingRule!=null
+ && enclosingRule.getLocalAttributeScope((ID4!=null?ID4.getText():null))!=null
+ && !enclosingRule.getLocalAttributeScope((ID4!=null?ID4.getText():null)).isPredefinedLexerRuleScope)) ) {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ throw new FailedPredicateException(input, "SET_LOCAL_ATTR", "enclosingRule!=null\n\t\t\t\t\t\t\t\t\t\t\t\t\t&& enclosingRule.getLocalAttributeScope($ID.text)!=null\n\t\t\t\t\t\t\t\t\t\t\t\t\t&& !enclosingRule.getLocalAttributeScope($ID.text).isPredefinedLexerRuleScope");
+ }
+ if ( state.backtracking==1 ) {
+
+ StringTemplate st;
+ AttributeScope scope = enclosingRule.getLocalAttributeScope((ID4!=null?ID4.getText():null));
+ if ( scope.isPredefinedRuleScope ) {
+ if ((ID4!=null?ID4.getText():null).equals("tree") || (ID4!=null?ID4.getText():null).equals("st")) {
+ st = template("ruleSetPropertyRef_"+(ID4!=null?ID4.getText():null));
+ grammar.referenceRuleLabelPredefinedAttribute(enclosingRule.name);
+ st.setAttribute("scope", enclosingRule.name);
+ st.setAttribute("attr", (ID4!=null?ID4.getText():null));
+ st.setAttribute("expr", translateAction((expr!=null?expr.getText():null)));
+ } else {
+ ErrorManager.grammarError(ErrorManager.MSG_WRITE_TO_READONLY_ATTR,
+ grammar,
+ actionToken,
+ (ID4!=null?ID4.getText():null),
+ "");
+ }
+ }
+ else if ( scope.isParameterScope ) {
+ st = template("parameterSetAttributeRef");
+ st.setAttribute("attr", scope.getAttribute((ID4!=null?ID4.getText():null)));
+ st.setAttribute("expr", translateAction((expr!=null?expr.getText():null)));
+ }
+ else {
+ st = template("returnSetAttributeRef");
+ st.setAttribute("ruleDescriptor", enclosingRule);
+ st.setAttribute("attr", scope.getAttribute((ID4!=null?ID4.getText():null)));
+ st.setAttribute("expr", translateAction((expr!=null?expr.getText():null)));
+ }
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "SET_LOCAL_ATTR"
+
+ // $ANTLR start "LOCAL_ATTR"
+ public final void mLOCAL_ATTR() throws RecognitionException {
+ try {
+ int _type = LOCAL_ATTR;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ Token ID5=null;
+
+ // org/antlr/grammar/v3/ActionTranslator.g:523:2: ( '$' ID {...}?)
+ // org/antlr/grammar/v3/ActionTranslator.g:523:4: '$' ID {...}?
+ {
+ match('$'); if (state.failed) return ;
+ int ID5Start422 = getCharIndex();
+ mID(); if (state.failed) return ;
+ ID5 = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, ID5Start422, getCharIndex()-1);
+ if ( !((enclosingRule!=null && enclosingRule.getLocalAttributeScope((ID5!=null?ID5.getText():null))!=null)) ) {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ throw new FailedPredicateException(input, "LOCAL_ATTR", "enclosingRule!=null && enclosingRule.getLocalAttributeScope($ID.text)!=null");
+ }
+ if ( state.backtracking==1 ) {
+
+ StringTemplate st;
+ AttributeScope scope = enclosingRule.getLocalAttributeScope((ID5!=null?ID5.getText():null));
+ if ( scope.isPredefinedRuleScope ) {
+ st = template("rulePropertyRef_"+(ID5!=null?ID5.getText():null));
+ grammar.referenceRuleLabelPredefinedAttribute(enclosingRule.name);
+ st.setAttribute("scope", enclosingRule.name);
+ st.setAttribute("attr", (ID5!=null?ID5.getText():null));
+ }
+ else if ( scope.isPredefinedLexerRuleScope ) {
+ st = template("lexerRulePropertyRef_"+(ID5!=null?ID5.getText():null));
+ st.setAttribute("scope", enclosingRule.name);
+ st.setAttribute("attr", (ID5!=null?ID5.getText():null));
+ }
+ else if ( scope.isParameterScope ) {
+ st = template("parameterAttributeRef");
+ st.setAttribute("attr", scope.getAttribute((ID5!=null?ID5.getText():null)));
+ }
+ else {
+ st = template("returnAttributeRef");
+ st.setAttribute("ruleDescriptor", enclosingRule);
+ st.setAttribute("attr", scope.getAttribute((ID5!=null?ID5.getText():null)));
+ }
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "LOCAL_ATTR"
+
+ // $ANTLR start "SET_DYNAMIC_SCOPE_ATTR"
+ public final void mSET_DYNAMIC_SCOPE_ATTR() throws RecognitionException {
+ try {
+ int _type = SET_DYNAMIC_SCOPE_ATTR;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ Token x=null;
+ Token y=null;
+ Token expr=null;
+
+ // org/antlr/grammar/v3/ActionTranslator.g:564:2: ( '$' x= ID '::' y= ID ( WS )? '=' expr= ATTR_VALUE_EXPR ';' {...}?)
+ // org/antlr/grammar/v3/ActionTranslator.g:564:4: '$' x= ID '::' y= ID ( WS )? '=' expr= ATTR_VALUE_EXPR ';' {...}?
+ {
+ match('$'); if (state.failed) return ;
+ int xStart448 = getCharIndex();
+ mID(); if (state.failed) return ;
+ x = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, xStart448, getCharIndex()-1);
+ match("::"); if (state.failed) return ;
+
+ int yStart454 = getCharIndex();
+ mID(); if (state.failed) return ;
+ y = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, yStart454, getCharIndex()-1);
+ // org/antlr/grammar/v3/ActionTranslator.g:564:23: ( WS )?
+ int alt5=2;
+ int LA5_0 = input.LA(1);
+
+ if ( ((LA5_0>='\t' && LA5_0<='\n')||LA5_0=='\r'||LA5_0==' ') ) {
+ alt5=1;
+ }
+ switch (alt5) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:564:23: WS
+ {
+ mWS(); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ match('='); if (state.failed) return ;
+ int exprStart463 = getCharIndex();
+ mATTR_VALUE_EXPR(); if (state.failed) return ;
+ expr = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, exprStart463, getCharIndex()-1);
+ match(';'); if (state.failed) return ;
+ if ( !((resolveDynamicScope((x!=null?x.getText():null))!=null &&
+ resolveDynamicScope((x!=null?x.getText():null)).getAttribute((y!=null?y.getText():null))!=null)) ) {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ throw new FailedPredicateException(input, "SET_DYNAMIC_SCOPE_ATTR", "resolveDynamicScope($x.text)!=null &&\n\t\t\t\t\t\t resolveDynamicScope($x.text).getAttribute($y.text)!=null");
+ }
+ if ( state.backtracking==1 ) {
+
+ AttributeScope scope = resolveDynamicScope((x!=null?x.getText():null));
+ if ( scope!=null ) {
+ StringTemplate st = template("scopeSetAttributeRef");
+ st.setAttribute("scope", (x!=null?x.getText():null));
+ st.setAttribute("attr", scope.getAttribute((y!=null?y.getText():null)));
+ st.setAttribute("expr", translateAction((expr!=null?expr.getText():null)));
+ }
+ else {
+ // error: invalid dynamic attribute
+ }
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "SET_DYNAMIC_SCOPE_ATTR"
+
+ // $ANTLR start "DYNAMIC_SCOPE_ATTR"
+ public final void mDYNAMIC_SCOPE_ATTR() throws RecognitionException {
+ try {
+ int _type = DYNAMIC_SCOPE_ATTR;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ Token x=null;
+ Token y=null;
+
+ // org/antlr/grammar/v3/ActionTranslator.g:583:2: ( '$' x= ID '::' y= ID {...}?)
+ // org/antlr/grammar/v3/ActionTranslator.g:583:4: '$' x= ID '::' y= ID {...}?
+ {
+ match('$'); if (state.failed) return ;
+ int xStart498 = getCharIndex();
+ mID(); if (state.failed) return ;
+ x = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, xStart498, getCharIndex()-1);
+ match("::"); if (state.failed) return ;
+
+ int yStart504 = getCharIndex();
+ mID(); if (state.failed) return ;
+ y = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, yStart504, getCharIndex()-1);
+ if ( !((resolveDynamicScope((x!=null?x.getText():null))!=null &&
+ resolveDynamicScope((x!=null?x.getText():null)).getAttribute((y!=null?y.getText():null))!=null)) ) {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ throw new FailedPredicateException(input, "DYNAMIC_SCOPE_ATTR", "resolveDynamicScope($x.text)!=null &&\n\t\t\t\t\t\t resolveDynamicScope($x.text).getAttribute($y.text)!=null");
+ }
+ if ( state.backtracking==1 ) {
+
+ AttributeScope scope = resolveDynamicScope((x!=null?x.getText():null));
+ if ( scope!=null ) {
+ StringTemplate st = template("scopeAttributeRef");
+ st.setAttribute("scope", (x!=null?x.getText():null));
+ st.setAttribute("attr", scope.getAttribute((y!=null?y.getText():null)));
+ }
+ else {
+ // error: invalid dynamic attribute
+ }
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "DYNAMIC_SCOPE_ATTR"
+
+ // $ANTLR start "ERROR_SCOPED_XY"
+ public final void mERROR_SCOPED_XY() throws RecognitionException {
+ try {
+ int _type = ERROR_SCOPED_XY;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ Token x=null;
+ Token y=null;
+
+ // org/antlr/grammar/v3/ActionTranslator.g:602:2: ( '$' x= ID '::' y= ID )
+ // org/antlr/grammar/v3/ActionTranslator.g:602:4: '$' x= ID '::' y= ID
+ {
+ match('$'); if (state.failed) return ;
+ int xStart538 = getCharIndex();
+ mID(); if (state.failed) return ;
+ x = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, xStart538, getCharIndex()-1);
+ match("::"); if (state.failed) return ;
+
+ int yStart544 = getCharIndex();
+ mID(); if (state.failed) return ;
+ y = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, yStart544, getCharIndex()-1);
+ if ( state.backtracking==1 ) {
+
+ chunks.add(getText());
+ generator.issueInvalidScopeError((x!=null?x.getText():null),(y!=null?y.getText():null),
+ enclosingRule,actionToken,
+ outerAltNum);
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "ERROR_SCOPED_XY"
+
+ // $ANTLR start "DYNAMIC_NEGATIVE_INDEXED_SCOPE_ATTR"
+ public final void mDYNAMIC_NEGATIVE_INDEXED_SCOPE_ATTR() throws RecognitionException {
+ try {
+ int _type = DYNAMIC_NEGATIVE_INDEXED_SCOPE_ATTR;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ Token x=null;
+ Token expr=null;
+ Token y=null;
+
+ // org/antlr/grammar/v3/ActionTranslator.g:620:2: ( '$' x= ID '[' '-' expr= SCOPE_INDEX_EXPR ']' '::' y= ID )
+ // org/antlr/grammar/v3/ActionTranslator.g:620:4: '$' x= ID '[' '-' expr= SCOPE_INDEX_EXPR ']' '::' y= ID
+ {
+ match('$'); if (state.failed) return ;
+ int xStart566 = getCharIndex();
+ mID(); if (state.failed) return ;
+ x = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, xStart566, getCharIndex()-1);
+ match('['); if (state.failed) return ;
+ match('-'); if (state.failed) return ;
+ int exprStart574 = getCharIndex();
+ mSCOPE_INDEX_EXPR(); if (state.failed) return ;
+ expr = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, exprStart574, getCharIndex()-1);
+ match(']'); if (state.failed) return ;
+ match("::"); if (state.failed) return ;
+
+ int yStart582 = getCharIndex();
+ mID(); if (state.failed) return ;
+ y = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, yStart582, getCharIndex()-1);
+ if ( state.backtracking==1 ) {
+
+ StringTemplate st = template("scopeAttributeRef");
+ st.setAttribute("scope", (x!=null?x.getText():null));
+ st.setAttribute("attr", resolveDynamicScope((x!=null?x.getText():null)).getAttribute((y!=null?y.getText():null)));
+ st.setAttribute("negIndex", (expr!=null?expr.getText():null));
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "DYNAMIC_NEGATIVE_INDEXED_SCOPE_ATTR"
+
+ // $ANTLR start "DYNAMIC_ABSOLUTE_INDEXED_SCOPE_ATTR"
+ public final void mDYNAMIC_ABSOLUTE_INDEXED_SCOPE_ATTR() throws RecognitionException {
+ try {
+ int _type = DYNAMIC_ABSOLUTE_INDEXED_SCOPE_ATTR;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ Token x=null;
+ Token expr=null;
+ Token y=null;
+
+ // org/antlr/grammar/v3/ActionTranslator.g:631:2: ( '$' x= ID '[' expr= SCOPE_INDEX_EXPR ']' '::' y= ID )
+ // org/antlr/grammar/v3/ActionTranslator.g:631:4: '$' x= ID '[' expr= SCOPE_INDEX_EXPR ']' '::' y= ID
+ {
+ match('$'); if (state.failed) return ;
+ int xStart606 = getCharIndex();
+ mID(); if (state.failed) return ;
+ x = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, xStart606, getCharIndex()-1);
+ match('['); if (state.failed) return ;
+ int exprStart612 = getCharIndex();
+ mSCOPE_INDEX_EXPR(); if (state.failed) return ;
+ expr = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, exprStart612, getCharIndex()-1);
+ match(']'); if (state.failed) return ;
+ match("::"); if (state.failed) return ;
+
+ int yStart620 = getCharIndex();
+ mID(); if (state.failed) return ;
+ y = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, yStart620, getCharIndex()-1);
+ if ( state.backtracking==1 ) {
+
+ StringTemplate st = template("scopeAttributeRef");
+ st.setAttribute("scope", (x!=null?x.getText():null));
+ st.setAttribute("attr", resolveDynamicScope((x!=null?x.getText():null)).getAttribute((y!=null?y.getText():null)));
+ st.setAttribute("index", (expr!=null?expr.getText():null));
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "DYNAMIC_ABSOLUTE_INDEXED_SCOPE_ATTR"
+
+ // $ANTLR start "SCOPE_INDEX_EXPR"
+ public final void mSCOPE_INDEX_EXPR() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ActionTranslator.g:643:2: ( (~ ']' )+ )
+ // org/antlr/grammar/v3/ActionTranslator.g:643:4: (~ ']' )+
+ {
+ // org/antlr/grammar/v3/ActionTranslator.g:643:4: (~ ']' )+
+ int cnt6=0;
+ loop6:
+ do {
+ int alt6=2;
+ int LA6_0 = input.LA(1);
+
+ if ( ((LA6_0>='\u0000' && LA6_0<='\\')||(LA6_0>='^' && LA6_0<='\uFFFF')) ) {
+ alt6=1;
+ }
+
+
+ switch (alt6) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:643:5: ~ ']'
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='\\')||(input.LA(1)>='^' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+ state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ if ( cnt6 >= 1 ) break loop6;
+ if (state.backtracking>0) {state.failed=true; return ;}
+ EarlyExitException eee =
+ new EarlyExitException(6, input);
+ throw eee;
+ }
+ cnt6++;
+ } while (true);
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "SCOPE_INDEX_EXPR"
+
+ // $ANTLR start "ISOLATED_DYNAMIC_SCOPE"
+ public final void mISOLATED_DYNAMIC_SCOPE() throws RecognitionException {
+ try {
+ int _type = ISOLATED_DYNAMIC_SCOPE;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ Token ID6=null;
+
+ // org/antlr/grammar/v3/ActionTranslator.g:652:2: ( '$' ID {...}?)
+ // org/antlr/grammar/v3/ActionTranslator.g:652:4: '$' ID {...}?
+ {
+ match('$'); if (state.failed) return ;
+ int ID6Start663 = getCharIndex();
+ mID(); if (state.failed) return ;
+ ID6 = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, ID6Start663, getCharIndex()-1);
+ if ( !((resolveDynamicScope((ID6!=null?ID6.getText():null))!=null)) ) {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ throw new FailedPredicateException(input, "ISOLATED_DYNAMIC_SCOPE", "resolveDynamicScope($ID.text)!=null");
+ }
+ if ( state.backtracking==1 ) {
+
+ StringTemplate st = template("isolatedDynamicScopeRef");
+ st.setAttribute("scope", (ID6!=null?ID6.getText():null));
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "ISOLATED_DYNAMIC_SCOPE"
+
+ // $ANTLR start "TEMPLATE_INSTANCE"
+ public final void mTEMPLATE_INSTANCE() throws RecognitionException {
+ try {
+ int _type = TEMPLATE_INSTANCE;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ActionTranslator.g:665:2: ( '%' ID '(' ( ( WS )? ARG ( ',' ( WS )? ARG )* ( WS )? )? ')' )
+ // org/antlr/grammar/v3/ActionTranslator.g:665:4: '%' ID '(' ( ( WS )? ARG ( ',' ( WS )? ARG )* ( WS )? )? ')'
+ {
+ match('%'); if (state.failed) return ;
+ mID(); if (state.failed) return ;
+ match('('); if (state.failed) return ;
+ // org/antlr/grammar/v3/ActionTranslator.g:665:15: ( ( WS )? ARG ( ',' ( WS )? ARG )* ( WS )? )?
+ int alt11=2;
+ int LA11_0 = input.LA(1);
+
+ if ( ((LA11_0>='\t' && LA11_0<='\n')||LA11_0=='\r'||LA11_0==' '||(LA11_0>='A' && LA11_0<='Z')||LA11_0=='_'||(LA11_0>='a' && LA11_0<='z')) ) {
+ alt11=1;
+ }
+ switch (alt11) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:665:17: ( WS )? ARG ( ',' ( WS )? ARG )* ( WS )?
+ {
+ // org/antlr/grammar/v3/ActionTranslator.g:665:17: ( WS )?
+ int alt7=2;
+ int LA7_0 = input.LA(1);
+
+ if ( ((LA7_0>='\t' && LA7_0<='\n')||LA7_0=='\r'||LA7_0==' ') ) {
+ alt7=1;
+ }
+ switch (alt7) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:665:17: WS
+ {
+ mWS(); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ mARG(); if (state.failed) return ;
+ // org/antlr/grammar/v3/ActionTranslator.g:665:25: ( ',' ( WS )? ARG )*
+ loop9:
+ do {
+ int alt9=2;
+ int LA9_0 = input.LA(1);
+
+ if ( (LA9_0==',') ) {
+ alt9=1;
+ }
+
+
+ switch (alt9) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:665:26: ',' ( WS )? ARG
+ {
+ match(','); if (state.failed) return ;
+ // org/antlr/grammar/v3/ActionTranslator.g:665:30: ( WS )?
+ int alt8=2;
+ int LA8_0 = input.LA(1);
+
+ if ( ((LA8_0>='\t' && LA8_0<='\n')||LA8_0=='\r'||LA8_0==' ') ) {
+ alt8=1;
+ }
+ switch (alt8) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:665:30: WS
+ {
+ mWS(); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ mARG(); if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop9;
+ }
+ } while (true);
+
+ // org/antlr/grammar/v3/ActionTranslator.g:665:40: ( WS )?
+ int alt10=2;
+ int LA10_0 = input.LA(1);
+
+ if ( ((LA10_0>='\t' && LA10_0<='\n')||LA10_0=='\r'||LA10_0==' ') ) {
+ alt10=1;
+ }
+ switch (alt10) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:665:40: WS
+ {
+ mWS(); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ match(')'); if (state.failed) return ;
+ if ( state.backtracking==1 ) {
+
+ String action = getText().substring(1,getText().length());
+ String ruleName = "<outside-of-rule>";
+ if ( enclosingRule!=null ) {
+ ruleName = enclosingRule.name;
+ }
+ StringTemplate st =
+ generator.translateTemplateConstructor(ruleName,
+ outerAltNum,
+ actionToken,
+ action);
+ if ( st!=null ) {
+ chunks.add(st);
+ }
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "TEMPLATE_INSTANCE"
+
+ // $ANTLR start "INDIRECT_TEMPLATE_INSTANCE"
+ public final void mINDIRECT_TEMPLATE_INSTANCE() throws RecognitionException {
+ try {
+ int _type = INDIRECT_TEMPLATE_INSTANCE;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ActionTranslator.g:686:2: ( '%' '(' ACTION ')' '(' ( ( WS )? ARG ( ',' ( WS )? ARG )* ( WS )? )? ')' )
+ // org/antlr/grammar/v3/ActionTranslator.g:686:4: '%' '(' ACTION ')' '(' ( ( WS )? ARG ( ',' ( WS )? ARG )* ( WS )? )? ')'
+ {
+ match('%'); if (state.failed) return ;
+ match('('); if (state.failed) return ;
+ mACTION(); if (state.failed) return ;
+ match(')'); if (state.failed) return ;
+ match('('); if (state.failed) return ;
+ // org/antlr/grammar/v3/ActionTranslator.g:686:27: ( ( WS )? ARG ( ',' ( WS )? ARG )* ( WS )? )?
+ int alt16=2;
+ int LA16_0 = input.LA(1);
+
+ if ( ((LA16_0>='\t' && LA16_0<='\n')||LA16_0=='\r'||LA16_0==' '||(LA16_0>='A' && LA16_0<='Z')||LA16_0=='_'||(LA16_0>='a' && LA16_0<='z')) ) {
+ alt16=1;
+ }
+ switch (alt16) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:686:29: ( WS )? ARG ( ',' ( WS )? ARG )* ( WS )?
+ {
+ // org/antlr/grammar/v3/ActionTranslator.g:686:29: ( WS )?
+ int alt12=2;
+ int LA12_0 = input.LA(1);
+
+ if ( ((LA12_0>='\t' && LA12_0<='\n')||LA12_0=='\r'||LA12_0==' ') ) {
+ alt12=1;
+ }
+ switch (alt12) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:686:29: WS
+ {
+ mWS(); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ mARG(); if (state.failed) return ;
+ // org/antlr/grammar/v3/ActionTranslator.g:686:37: ( ',' ( WS )? ARG )*
+ loop14:
+ do {
+ int alt14=2;
+ int LA14_0 = input.LA(1);
+
+ if ( (LA14_0==',') ) {
+ alt14=1;
+ }
+
+
+ switch (alt14) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:686:38: ',' ( WS )? ARG
+ {
+ match(','); if (state.failed) return ;
+ // org/antlr/grammar/v3/ActionTranslator.g:686:42: ( WS )?
+ int alt13=2;
+ int LA13_0 = input.LA(1);
+
+ if ( ((LA13_0>='\t' && LA13_0<='\n')||LA13_0=='\r'||LA13_0==' ') ) {
+ alt13=1;
+ }
+ switch (alt13) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:686:42: WS
+ {
+ mWS(); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ mARG(); if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop14;
+ }
+ } while (true);
+
+ // org/antlr/grammar/v3/ActionTranslator.g:686:52: ( WS )?
+ int alt15=2;
+ int LA15_0 = input.LA(1);
+
+ if ( ((LA15_0>='\t' && LA15_0<='\n')||LA15_0=='\r'||LA15_0==' ') ) {
+ alt15=1;
+ }
+ switch (alt15) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:686:52: WS
+ {
+ mWS(); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ match(')'); if (state.failed) return ;
+ if ( state.backtracking==1 ) {
+
+ String action = getText().substring(1,getText().length());
+ StringTemplate st =
+ generator.translateTemplateConstructor(enclosingRule.name,
+ outerAltNum,
+ actionToken,
+ action);
+ chunks.add(st);
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "INDIRECT_TEMPLATE_INSTANCE"
+
+ // $ANTLR start "ARG"
+ public final void mARG() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ActionTranslator.g:700:5: ( ID '=' ACTION )
+ // org/antlr/grammar/v3/ActionTranslator.g:700:7: ID '=' ACTION
+ {
+ mID(); if (state.failed) return ;
+ match('='); if (state.failed) return ;
+ mACTION(); if (state.failed) return ;
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "ARG"
+
+ // $ANTLR start "SET_EXPR_ATTRIBUTE"
+ public final void mSET_EXPR_ATTRIBUTE() throws RecognitionException {
+ try {
+ int _type = SET_EXPR_ATTRIBUTE;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ Token a=null;
+ Token expr=null;
+ Token ID7=null;
+
+ // org/antlr/grammar/v3/ActionTranslator.g:705:2: ( '%' a= ACTION '.' ID ( WS )? '=' expr= ATTR_VALUE_EXPR ';' )
+ // org/antlr/grammar/v3/ActionTranslator.g:705:4: '%' a= ACTION '.' ID ( WS )? '=' expr= ATTR_VALUE_EXPR ';'
+ {
+ match('%'); if (state.failed) return ;
+ int aStart813 = getCharIndex();
+ mACTION(); if (state.failed) return ;
+ a = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, aStart813, getCharIndex()-1);
+ match('.'); if (state.failed) return ;
+ int ID7Start817 = getCharIndex();
+ mID(); if (state.failed) return ;
+ ID7 = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, ID7Start817, getCharIndex()-1);
+ // org/antlr/grammar/v3/ActionTranslator.g:705:24: ( WS )?
+ int alt17=2;
+ int LA17_0 = input.LA(1);
+
+ if ( ((LA17_0>='\t' && LA17_0<='\n')||LA17_0=='\r'||LA17_0==' ') ) {
+ alt17=1;
+ }
+ switch (alt17) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:705:24: WS
+ {
+ mWS(); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ match('='); if (state.failed) return ;
+ int exprStart826 = getCharIndex();
+ mATTR_VALUE_EXPR(); if (state.failed) return ;
+ expr = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, exprStart826, getCharIndex()-1);
+ match(';'); if (state.failed) return ;
+ if ( state.backtracking==1 ) {
+
+ StringTemplate st = template("actionSetAttribute");
+ String action = (a!=null?a.getText():null);
+ action = action.substring(1,action.length()-1); // stuff inside {...}
+ st.setAttribute("st", translateAction(action));
+ st.setAttribute("attrName", (ID7!=null?ID7.getText():null));
+ st.setAttribute("expr", translateAction((expr!=null?expr.getText():null)));
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "SET_EXPR_ATTRIBUTE"
+
+ // $ANTLR start "SET_ATTRIBUTE"
+ public final void mSET_ATTRIBUTE() throws RecognitionException {
+ try {
+ int _type = SET_ATTRIBUTE;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ Token x=null;
+ Token y=null;
+ Token expr=null;
+
+ // org/antlr/grammar/v3/ActionTranslator.g:722:2: ( '%' x= ID '.' y= ID ( WS )? '=' expr= ATTR_VALUE_EXPR ';' )
+ // org/antlr/grammar/v3/ActionTranslator.g:722:4: '%' x= ID '.' y= ID ( WS )? '=' expr= ATTR_VALUE_EXPR ';'
+ {
+ match('%'); if (state.failed) return ;
+ int xStart853 = getCharIndex();
+ mID(); if (state.failed) return ;
+ x = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, xStart853, getCharIndex()-1);
+ match('.'); if (state.failed) return ;
+ int yStart859 = getCharIndex();
+ mID(); if (state.failed) return ;
+ y = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, yStart859, getCharIndex()-1);
+ // org/antlr/grammar/v3/ActionTranslator.g:722:22: ( WS )?
+ int alt18=2;
+ int LA18_0 = input.LA(1);
+
+ if ( ((LA18_0>='\t' && LA18_0<='\n')||LA18_0=='\r'||LA18_0==' ') ) {
+ alt18=1;
+ }
+ switch (alt18) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:722:22: WS
+ {
+ mWS(); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ match('='); if (state.failed) return ;
+ int exprStart868 = getCharIndex();
+ mATTR_VALUE_EXPR(); if (state.failed) return ;
+ expr = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, exprStart868, getCharIndex()-1);
+ match(';'); if (state.failed) return ;
+ if ( state.backtracking==1 ) {
+
+ StringTemplate st = template("actionSetAttribute");
+ st.setAttribute("st", (x!=null?x.getText():null));
+ st.setAttribute("attrName", (y!=null?y.getText():null));
+ st.setAttribute("expr", translateAction((expr!=null?expr.getText():null)));
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "SET_ATTRIBUTE"
+
+ // $ANTLR start "ATTR_VALUE_EXPR"
+ public final void mATTR_VALUE_EXPR() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ActionTranslator.g:735:2: (~ '=' (~ ';' )* )
+ // org/antlr/grammar/v3/ActionTranslator.g:735:4: ~ '=' (~ ';' )*
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='<')||(input.LA(1)>='>' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+ state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ // org/antlr/grammar/v3/ActionTranslator.g:735:9: (~ ';' )*
+ loop19:
+ do {
+ int alt19=2;
+ int LA19_0 = input.LA(1);
+
+ if ( ((LA19_0>='\u0000' && LA19_0<=':')||(LA19_0>='<' && LA19_0<='\uFFFF')) ) {
+ alt19=1;
+ }
+
+
+ switch (alt19) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:735:10: ~ ';'
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<=':')||(input.LA(1)>='<' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+ state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop19;
+ }
+ } while (true);
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "ATTR_VALUE_EXPR"
+
+ // $ANTLR start "TEMPLATE_EXPR"
+ public final void mTEMPLATE_EXPR() throws RecognitionException {
+ try {
+ int _type = TEMPLATE_EXPR;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ Token a=null;
+
+ // org/antlr/grammar/v3/ActionTranslator.g:740:2: ( '%' a= ACTION )
+ // org/antlr/grammar/v3/ActionTranslator.g:740:4: '%' a= ACTION
+ {
+ match('%'); if (state.failed) return ;
+ int aStart917 = getCharIndex();
+ mACTION(); if (state.failed) return ;
+ a = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, aStart917, getCharIndex()-1);
+ if ( state.backtracking==1 ) {
+
+ StringTemplate st = template("actionStringConstructor");
+ String action = (a!=null?a.getText():null);
+ action = action.substring(1,action.length()-1); // stuff inside {...}
+ st.setAttribute("stringExpr", translateAction(action));
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "TEMPLATE_EXPR"
+
+ // $ANTLR start "ACTION"
+ public final void mACTION() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ActionTranslator.g:752:2: ( '{' ( options {greedy=false; } : . )* '}' )
+ // org/antlr/grammar/v3/ActionTranslator.g:752:4: '{' ( options {greedy=false; } : . )* '}'
+ {
+ match('{'); if (state.failed) return ;
+ // org/antlr/grammar/v3/ActionTranslator.g:752:8: ( options {greedy=false; } : . )*
+ loop20:
+ do {
+ int alt20=2;
+ int LA20_0 = input.LA(1);
+
+ if ( (LA20_0=='}') ) {
+ alt20=2;
+ }
+ else if ( ((LA20_0>='\u0000' && LA20_0<='|')||(LA20_0>='~' && LA20_0<='\uFFFF')) ) {
+ alt20=1;
+ }
+
+
+ switch (alt20) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:752:33: .
+ {
+ matchAny(); if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop20;
+ }
+ } while (true);
+
+ match('}'); if (state.failed) return ;
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "ACTION"
+
+ // $ANTLR start "ESC"
+ public final void mESC() throws RecognitionException {
+ try {
+ int _type = ESC;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ActionTranslator.g:755:5: ( '\\\\' '$' | '\\\\' '%' | '\\\\' ~ ( '$' | '%' ) )
+ int alt21=3;
+ int LA21_0 = input.LA(1);
+
+ if ( (LA21_0=='\\') ) {
+ int LA21_1 = input.LA(2);
+
+ if ( (LA21_1=='$') ) {
+ alt21=1;
+ }
+ else if ( (LA21_1=='%') ) {
+ alt21=2;
+ }
+ else if ( ((LA21_1>='\u0000' && LA21_1<='#')||(LA21_1>='&' && LA21_1<='\uFFFF')) ) {
+ alt21=3;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 21, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 21, 0, input);
+
+ throw nvae;
+ }
+ switch (alt21) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:755:9: '\\\\' '$'
+ {
+ match('\\'); if (state.failed) return ;
+ match('$'); if (state.failed) return ;
+ if ( state.backtracking==1 ) {
+ chunks.add("$");
+ }
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ActionTranslator.g:756:4: '\\\\' '%'
+ {
+ match('\\'); if (state.failed) return ;
+ match('%'); if (state.failed) return ;
+ if ( state.backtracking==1 ) {
+ chunks.add("%");
+ }
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ActionTranslator.g:757:4: '\\\\' ~ ( '$' | '%' )
+ {
+ match('\\'); if (state.failed) return ;
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='#')||(input.LA(1)>='&' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+ state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ if ( state.backtracking==1 ) {
+ chunks.add(getText());
+ }
+
+ }
+ break;
+
+ }
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "ESC"
+
+ // $ANTLR start "ERROR_XY"
+ public final void mERROR_XY() throws RecognitionException {
+ try {
+ int _type = ERROR_XY;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ Token x=null;
+ Token y=null;
+
+ // org/antlr/grammar/v3/ActionTranslator.g:761:2: ( '$' x= ID '.' y= ID )
+ // org/antlr/grammar/v3/ActionTranslator.g:761:4: '$' x= ID '.' y= ID
+ {
+ match('$'); if (state.failed) return ;
+ int xStart1017 = getCharIndex();
+ mID(); if (state.failed) return ;
+ x = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, xStart1017, getCharIndex()-1);
+ match('.'); if (state.failed) return ;
+ int yStart1023 = getCharIndex();
+ mID(); if (state.failed) return ;
+ y = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, yStart1023, getCharIndex()-1);
+ if ( state.backtracking==1 ) {
+
+ chunks.add(getText());
+ generator.issueInvalidAttributeError((x!=null?x.getText():null),(y!=null?y.getText():null),
+ enclosingRule,actionToken,
+ outerAltNum);
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "ERROR_XY"
+
+ // $ANTLR start "ERROR_X"
+ public final void mERROR_X() throws RecognitionException {
+ try {
+ int _type = ERROR_X;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ Token x=null;
+
+ // org/antlr/grammar/v3/ActionTranslator.g:771:2: ( '$' x= ID )
+ // org/antlr/grammar/v3/ActionTranslator.g:771:4: '$' x= ID
+ {
+ match('$'); if (state.failed) return ;
+ int xStart1043 = getCharIndex();
+ mID(); if (state.failed) return ;
+ x = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, xStart1043, getCharIndex()-1);
+ if ( state.backtracking==1 ) {
+
+ chunks.add(getText());
+ generator.issueInvalidAttributeError((x!=null?x.getText():null),
+ enclosingRule,actionToken,
+ outerAltNum);
+
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "ERROR_X"
+
+ // $ANTLR start "UNKNOWN_SYNTAX"
+ public final void mUNKNOWN_SYNTAX() throws RecognitionException {
+ try {
+ int _type = UNKNOWN_SYNTAX;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ActionTranslator.g:781:2: ( '$' | '%' ( ID | '.' | '(' | ')' | ',' | '{' | '}' | '\"' )* )
+ int alt23=2;
+ int LA23_0 = input.LA(1);
+
+ if ( (LA23_0=='$') ) {
+ alt23=1;
+ }
+ else if ( (LA23_0=='%') ) {
+ alt23=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 23, 0, input);
+
+ throw nvae;
+ }
+ switch (alt23) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:781:4: '$'
+ {
+ match('$'); if (state.failed) return ;
+ if ( state.backtracking==1 ) {
+
+ chunks.add(getText());
+ // shouldn't need an error here. Just accept $ if it doesn't look like anything
+
+ }
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ActionTranslator.g:786:4: '%' ( ID | '.' | '(' | ')' | ',' | '{' | '}' | '\"' )*
+ {
+ match('%'); if (state.failed) return ;
+ // org/antlr/grammar/v3/ActionTranslator.g:786:8: ( ID | '.' | '(' | ')' | ',' | '{' | '}' | '\"' )*
+ loop22:
+ do {
+ int alt22=9;
+ alt22 = dfa22.predict(input);
+ switch (alt22) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:786:9: ID
+ {
+ mID(); if (state.failed) return ;
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ActionTranslator.g:786:12: '.'
+ {
+ match('.'); if (state.failed) return ;
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ActionTranslator.g:786:16: '('
+ {
+ match('('); if (state.failed) return ;
+
+ }
+ break;
+ case 4 :
+ // org/antlr/grammar/v3/ActionTranslator.g:786:20: ')'
+ {
+ match(')'); if (state.failed) return ;
+
+ }
+ break;
+ case 5 :
+ // org/antlr/grammar/v3/ActionTranslator.g:786:24: ','
+ {
+ match(','); if (state.failed) return ;
+
+ }
+ break;
+ case 6 :
+ // org/antlr/grammar/v3/ActionTranslator.g:786:28: '{'
+ {
+ match('{'); if (state.failed) return ;
+
+ }
+ break;
+ case 7 :
+ // org/antlr/grammar/v3/ActionTranslator.g:786:32: '}'
+ {
+ match('}'); if (state.failed) return ;
+
+ }
+ break;
+ case 8 :
+ // org/antlr/grammar/v3/ActionTranslator.g:786:36: '\"'
+ {
+ match('\"'); if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop22;
+ }
+ } while (true);
+
+ if ( state.backtracking==1 ) {
+
+ chunks.add(getText());
+ ErrorManager.grammarError(ErrorManager.MSG_INVALID_TEMPLATE_ACTION,
+ grammar,
+ actionToken,
+ getText());
+
+ }
+
+ }
+ break;
+
+ }
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "UNKNOWN_SYNTAX"
+
+ // $ANTLR start "TEXT"
+ public final void mTEXT() throws RecognitionException {
+ try {
+ int _type = TEXT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // org/antlr/grammar/v3/ActionTranslator.g:796:5: ( (~ ( '$' | '%' | '\\\\' ) )+ )
+ // org/antlr/grammar/v3/ActionTranslator.g:796:7: (~ ( '$' | '%' | '\\\\' ) )+
+ {
+ // org/antlr/grammar/v3/ActionTranslator.g:796:7: (~ ( '$' | '%' | '\\\\' ) )+
+ int cnt24=0;
+ loop24:
+ do {
+ int alt24=2;
+ int LA24_0 = input.LA(1);
+
+ if ( ((LA24_0>='\u0000' && LA24_0<='#')||(LA24_0>='&' && LA24_0<='[')||(LA24_0>=']' && LA24_0<='\uFFFF')) ) {
+ alt24=1;
+ }
+
+
+ switch (alt24) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:796:7: ~ ( '$' | '%' | '\\\\' )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='#')||(input.LA(1)>='&' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+ state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ if ( cnt24 >= 1 ) break loop24;
+ if (state.backtracking>0) {state.failed=true; return ;}
+ EarlyExitException eee =
+ new EarlyExitException(24, input);
+ throw eee;
+ }
+ cnt24++;
+ } while (true);
+
+ if ( state.backtracking==1 ) {
+ chunks.add(getText());
+ }
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "TEXT"
+
+ // $ANTLR start "ID"
+ public final void mID() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ActionTranslator.g:800:5: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* )
+ // org/antlr/grammar/v3/ActionTranslator.g:800:9: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
+ {
+ if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
+ input.consume();
+ state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ // org/antlr/grammar/v3/ActionTranslator.g:800:33: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
+ loop25:
+ do {
+ int alt25=2;
+ int LA25_0 = input.LA(1);
+
+ if ( ((LA25_0>='0' && LA25_0<='9')||(LA25_0>='A' && LA25_0<='Z')||LA25_0=='_'||(LA25_0>='a' && LA25_0<='z')) ) {
+ alt25=1;
+ }
+
+
+ switch (alt25) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:
+ {
+ if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
+ input.consume();
+ state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop25;
+ }
+ } while (true);
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "ID"
+
+ // $ANTLR start "INT"
+ public final void mINT() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ActionTranslator.g:804:5: ( ( '0' .. '9' )+ )
+ // org/antlr/grammar/v3/ActionTranslator.g:804:7: ( '0' .. '9' )+
+ {
+ // org/antlr/grammar/v3/ActionTranslator.g:804:7: ( '0' .. '9' )+
+ int cnt26=0;
+ loop26:
+ do {
+ int alt26=2;
+ int LA26_0 = input.LA(1);
+
+ if ( ((LA26_0>='0' && LA26_0<='9')) ) {
+ alt26=1;
+ }
+
+
+ switch (alt26) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:804:7: '0' .. '9'
+ {
+ matchRange('0','9'); if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ if ( cnt26 >= 1 ) break loop26;
+ if (state.backtracking>0) {state.failed=true; return ;}
+ EarlyExitException eee =
+ new EarlyExitException(26, input);
+ throw eee;
+ }
+ cnt26++;
+ } while (true);
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "INT"
+
+ // $ANTLR start "WS"
+ public final void mWS() throws RecognitionException {
+ try {
+ // org/antlr/grammar/v3/ActionTranslator.g:808:4: ( ( ' ' | '\\t' | '\\n' | '\\r' )+ )
+ // org/antlr/grammar/v3/ActionTranslator.g:808:6: ( ' ' | '\\t' | '\\n' | '\\r' )+
+ {
+ // org/antlr/grammar/v3/ActionTranslator.g:808:6: ( ' ' | '\\t' | '\\n' | '\\r' )+
+ int cnt27=0;
+ loop27:
+ do {
+ int alt27=2;
+ int LA27_0 = input.LA(1);
+
+ if ( ((LA27_0>='\t' && LA27_0<='\n')||LA27_0=='\r'||LA27_0==' ') ) {
+ alt27=1;
+ }
+
+
+ switch (alt27) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:
+ {
+ if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) {
+ input.consume();
+ state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ if ( cnt27 >= 1 ) break loop27;
+ if (state.backtracking>0) {state.failed=true; return ;}
+ EarlyExitException eee =
+ new EarlyExitException(27, input);
+ throw eee;
+ }
+ cnt27++;
+ } while (true);
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "WS"
+
+ public void mTokens() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionTranslator.g:1:39: ( SET_ENCLOSING_RULE_SCOPE_ATTR | ENCLOSING_RULE_SCOPE_ATTR | SET_TOKEN_SCOPE_ATTR | TOKEN_SCOPE_ATTR | SET_RULE_SCOPE_ATTR | RULE_SCOPE_ATTR | LABEL_REF | ISOLATED_TOKEN_REF | ISOLATED_LEXER_RULE_REF | SET_LOCAL_ATTR | LOCAL_ATTR | SET_DYNAMIC_SCOPE_ATTR | DYNAMIC_SCOPE_ATTR | ERROR_SCOPED_XY | DYNAMIC_NEGATIVE_INDEXED_SCOPE_ATTR | DYNAMIC_ABSOLUTE_INDEXED_SCOPE_ATTR | ISOLATED_DYNAMIC_SCOPE | TEMPLATE_INSTANCE | INDIRECT_TEMPLATE [...]
+ int alt28=27;
+ alt28 = dfa28.predict(input);
+ switch (alt28) {
+ case 1 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:41: SET_ENCLOSING_RULE_SCOPE_ATTR
+ {
+ mSET_ENCLOSING_RULE_SCOPE_ATTR(); if (state.failed) return ;
+
+ }
+ break;
+ case 2 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:71: ENCLOSING_RULE_SCOPE_ATTR
+ {
+ mENCLOSING_RULE_SCOPE_ATTR(); if (state.failed) return ;
+
+ }
+ break;
+ case 3 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:97: SET_TOKEN_SCOPE_ATTR
+ {
+ mSET_TOKEN_SCOPE_ATTR(); if (state.failed) return ;
+
+ }
+ break;
+ case 4 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:118: TOKEN_SCOPE_ATTR
+ {
+ mTOKEN_SCOPE_ATTR(); if (state.failed) return ;
+
+ }
+ break;
+ case 5 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:135: SET_RULE_SCOPE_ATTR
+ {
+ mSET_RULE_SCOPE_ATTR(); if (state.failed) return ;
+
+ }
+ break;
+ case 6 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:155: RULE_SCOPE_ATTR
+ {
+ mRULE_SCOPE_ATTR(); if (state.failed) return ;
+
+ }
+ break;
+ case 7 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:171: LABEL_REF
+ {
+ mLABEL_REF(); if (state.failed) return ;
+
+ }
+ break;
+ case 8 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:181: ISOLATED_TOKEN_REF
+ {
+ mISOLATED_TOKEN_REF(); if (state.failed) return ;
+
+ }
+ break;
+ case 9 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:200: ISOLATED_LEXER_RULE_REF
+ {
+ mISOLATED_LEXER_RULE_REF(); if (state.failed) return ;
+
+ }
+ break;
+ case 10 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:224: SET_LOCAL_ATTR
+ {
+ mSET_LOCAL_ATTR(); if (state.failed) return ;
+
+ }
+ break;
+ case 11 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:239: LOCAL_ATTR
+ {
+ mLOCAL_ATTR(); if (state.failed) return ;
+
+ }
+ break;
+ case 12 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:250: SET_DYNAMIC_SCOPE_ATTR
+ {
+ mSET_DYNAMIC_SCOPE_ATTR(); if (state.failed) return ;
+
+ }
+ break;
+ case 13 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:273: DYNAMIC_SCOPE_ATTR
+ {
+ mDYNAMIC_SCOPE_ATTR(); if (state.failed) return ;
+
+ }
+ break;
+ case 14 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:292: ERROR_SCOPED_XY
+ {
+ mERROR_SCOPED_XY(); if (state.failed) return ;
+
+ }
+ break;
+ case 15 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:308: DYNAMIC_NEGATIVE_INDEXED_SCOPE_ATTR
+ {
+ mDYNAMIC_NEGATIVE_INDEXED_SCOPE_ATTR(); if (state.failed) return ;
+
+ }
+ break;
+ case 16 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:344: DYNAMIC_ABSOLUTE_INDEXED_SCOPE_ATTR
+ {
+ mDYNAMIC_ABSOLUTE_INDEXED_SCOPE_ATTR(); if (state.failed) return ;
+
+ }
+ break;
+ case 17 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:380: ISOLATED_DYNAMIC_SCOPE
+ {
+ mISOLATED_DYNAMIC_SCOPE(); if (state.failed) return ;
+
+ }
+ break;
+ case 18 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:403: TEMPLATE_INSTANCE
+ {
+ mTEMPLATE_INSTANCE(); if (state.failed) return ;
+
+ }
+ break;
+ case 19 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:421: INDIRECT_TEMPLATE_INSTANCE
+ {
+ mINDIRECT_TEMPLATE_INSTANCE(); if (state.failed) return ;
+
+ }
+ break;
+ case 20 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:448: SET_EXPR_ATTRIBUTE
+ {
+ mSET_EXPR_ATTRIBUTE(); if (state.failed) return ;
+
+ }
+ break;
+ case 21 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:467: SET_ATTRIBUTE
+ {
+ mSET_ATTRIBUTE(); if (state.failed) return ;
+
+ }
+ break;
+ case 22 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:481: TEMPLATE_EXPR
+ {
+ mTEMPLATE_EXPR(); if (state.failed) return ;
+
+ }
+ break;
+ case 23 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:495: ESC
+ {
+ mESC(); if (state.failed) return ;
+
+ }
+ break;
+ case 24 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:499: ERROR_XY
+ {
+ mERROR_XY(); if (state.failed) return ;
+
+ }
+ break;
+ case 25 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:508: ERROR_X
+ {
+ mERROR_X(); if (state.failed) return ;
+
+ }
+ break;
+ case 26 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:516: UNKNOWN_SYNTAX
+ {
+ mUNKNOWN_SYNTAX(); if (state.failed) return ;
+
+ }
+ break;
+ case 27 :
+ // org/antlr/grammar/v3/ActionTranslator.g:1:531: TEXT
+ {
+ mTEXT(); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ }
+
+ // $ANTLR start synpred1_ActionTranslator
+ public final void synpred1_ActionTranslator_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionTranslator.g:1:41: ( SET_ENCLOSING_RULE_SCOPE_ATTR )
+ // org/antlr/grammar/v3/ActionTranslator.g:1:41: SET_ENCLOSING_RULE_SCOPE_ATTR
+ {
+ mSET_ENCLOSING_RULE_SCOPE_ATTR(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred1_ActionTranslator
+
+ // $ANTLR start synpred2_ActionTranslator
+ public final void synpred2_ActionTranslator_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionTranslator.g:1:71: ( ENCLOSING_RULE_SCOPE_ATTR )
+ // org/antlr/grammar/v3/ActionTranslator.g:1:71: ENCLOSING_RULE_SCOPE_ATTR
+ {
+ mENCLOSING_RULE_SCOPE_ATTR(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred2_ActionTranslator
+
+ // $ANTLR start synpred3_ActionTranslator
+ public final void synpred3_ActionTranslator_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionTranslator.g:1:97: ( SET_TOKEN_SCOPE_ATTR )
+ // org/antlr/grammar/v3/ActionTranslator.g:1:97: SET_TOKEN_SCOPE_ATTR
+ {
+ mSET_TOKEN_SCOPE_ATTR(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred3_ActionTranslator
+
+ // $ANTLR start synpred4_ActionTranslator
+ public final void synpred4_ActionTranslator_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionTranslator.g:1:118: ( TOKEN_SCOPE_ATTR )
+ // org/antlr/grammar/v3/ActionTranslator.g:1:118: TOKEN_SCOPE_ATTR
+ {
+ mTOKEN_SCOPE_ATTR(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred4_ActionTranslator
+
+ // $ANTLR start synpred5_ActionTranslator
+ public final void synpred5_ActionTranslator_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionTranslator.g:1:135: ( SET_RULE_SCOPE_ATTR )
+ // org/antlr/grammar/v3/ActionTranslator.g:1:135: SET_RULE_SCOPE_ATTR
+ {
+ mSET_RULE_SCOPE_ATTR(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred5_ActionTranslator
+
+ // $ANTLR start synpred6_ActionTranslator
+ public final void synpred6_ActionTranslator_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionTranslator.g:1:155: ( RULE_SCOPE_ATTR )
+ // org/antlr/grammar/v3/ActionTranslator.g:1:155: RULE_SCOPE_ATTR
+ {
+ mRULE_SCOPE_ATTR(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred6_ActionTranslator
+
+ // $ANTLR start synpred7_ActionTranslator
+ public final void synpred7_ActionTranslator_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionTranslator.g:1:171: ( LABEL_REF )
+ // org/antlr/grammar/v3/ActionTranslator.g:1:171: LABEL_REF
+ {
+ mLABEL_REF(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred7_ActionTranslator
+
+ // $ANTLR start synpred8_ActionTranslator
+ public final void synpred8_ActionTranslator_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionTranslator.g:1:181: ( ISOLATED_TOKEN_REF )
+ // org/antlr/grammar/v3/ActionTranslator.g:1:181: ISOLATED_TOKEN_REF
+ {
+ mISOLATED_TOKEN_REF(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred8_ActionTranslator
+
+ // $ANTLR start synpred9_ActionTranslator
+ public final void synpred9_ActionTranslator_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionTranslator.g:1:200: ( ISOLATED_LEXER_RULE_REF )
+ // org/antlr/grammar/v3/ActionTranslator.g:1:200: ISOLATED_LEXER_RULE_REF
+ {
+ mISOLATED_LEXER_RULE_REF(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred9_ActionTranslator
+
+ // $ANTLR start synpred10_ActionTranslator
+ public final void synpred10_ActionTranslator_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionTranslator.g:1:224: ( SET_LOCAL_ATTR )
+ // org/antlr/grammar/v3/ActionTranslator.g:1:224: SET_LOCAL_ATTR
+ {
+ mSET_LOCAL_ATTR(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred10_ActionTranslator
+
+ // $ANTLR start synpred11_ActionTranslator
+ public final void synpred11_ActionTranslator_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionTranslator.g:1:239: ( LOCAL_ATTR )
+ // org/antlr/grammar/v3/ActionTranslator.g:1:239: LOCAL_ATTR
+ {
+ mLOCAL_ATTR(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred11_ActionTranslator
+
+ // $ANTLR start synpred12_ActionTranslator
+ public final void synpred12_ActionTranslator_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionTranslator.g:1:250: ( SET_DYNAMIC_SCOPE_ATTR )
+ // org/antlr/grammar/v3/ActionTranslator.g:1:250: SET_DYNAMIC_SCOPE_ATTR
+ {
+ mSET_DYNAMIC_SCOPE_ATTR(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred12_ActionTranslator
+
+ // $ANTLR start synpred13_ActionTranslator
+ public final void synpred13_ActionTranslator_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionTranslator.g:1:273: ( DYNAMIC_SCOPE_ATTR )
+ // org/antlr/grammar/v3/ActionTranslator.g:1:273: DYNAMIC_SCOPE_ATTR
+ {
+ mDYNAMIC_SCOPE_ATTR(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred13_ActionTranslator
+
+ // $ANTLR start synpred14_ActionTranslator
+ public final void synpred14_ActionTranslator_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionTranslator.g:1:292: ( ERROR_SCOPED_XY )
+ // org/antlr/grammar/v3/ActionTranslator.g:1:292: ERROR_SCOPED_XY
+ {
+ mERROR_SCOPED_XY(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred14_ActionTranslator
+
+ // $ANTLR start synpred15_ActionTranslator
+ public final void synpred15_ActionTranslator_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionTranslator.g:1:308: ( DYNAMIC_NEGATIVE_INDEXED_SCOPE_ATTR )
+ // org/antlr/grammar/v3/ActionTranslator.g:1:308: DYNAMIC_NEGATIVE_INDEXED_SCOPE_ATTR
+ {
+ mDYNAMIC_NEGATIVE_INDEXED_SCOPE_ATTR(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred15_ActionTranslator
+
+ // $ANTLR start synpred16_ActionTranslator
+ public final void synpred16_ActionTranslator_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionTranslator.g:1:344: ( DYNAMIC_ABSOLUTE_INDEXED_SCOPE_ATTR )
+ // org/antlr/grammar/v3/ActionTranslator.g:1:344: DYNAMIC_ABSOLUTE_INDEXED_SCOPE_ATTR
+ {
+ mDYNAMIC_ABSOLUTE_INDEXED_SCOPE_ATTR(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred16_ActionTranslator
+
+ // $ANTLR start synpred17_ActionTranslator
+ public final void synpred17_ActionTranslator_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionTranslator.g:1:380: ( ISOLATED_DYNAMIC_SCOPE )
+ // org/antlr/grammar/v3/ActionTranslator.g:1:380: ISOLATED_DYNAMIC_SCOPE
+ {
+ mISOLATED_DYNAMIC_SCOPE(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred17_ActionTranslator
+
+ // $ANTLR start synpred18_ActionTranslator
+ public final void synpred18_ActionTranslator_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionTranslator.g:1:403: ( TEMPLATE_INSTANCE )
+ // org/antlr/grammar/v3/ActionTranslator.g:1:403: TEMPLATE_INSTANCE
+ {
+ mTEMPLATE_INSTANCE(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred18_ActionTranslator
+
+ // $ANTLR start synpred19_ActionTranslator
+ public final void synpred19_ActionTranslator_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionTranslator.g:1:421: ( INDIRECT_TEMPLATE_INSTANCE )
+ // org/antlr/grammar/v3/ActionTranslator.g:1:421: INDIRECT_TEMPLATE_INSTANCE
+ {
+ mINDIRECT_TEMPLATE_INSTANCE(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred19_ActionTranslator
+
+ // $ANTLR start synpred20_ActionTranslator
+ public final void synpred20_ActionTranslator_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionTranslator.g:1:448: ( SET_EXPR_ATTRIBUTE )
+ // org/antlr/grammar/v3/ActionTranslator.g:1:448: SET_EXPR_ATTRIBUTE
+ {
+ mSET_EXPR_ATTRIBUTE(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred20_ActionTranslator
+
+ // $ANTLR start synpred21_ActionTranslator
+ public final void synpred21_ActionTranslator_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionTranslator.g:1:467: ( SET_ATTRIBUTE )
+ // org/antlr/grammar/v3/ActionTranslator.g:1:467: SET_ATTRIBUTE
+ {
+ mSET_ATTRIBUTE(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred21_ActionTranslator
+
+ // $ANTLR start synpred22_ActionTranslator
+ public final void synpred22_ActionTranslator_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionTranslator.g:1:481: ( TEMPLATE_EXPR )
+ // org/antlr/grammar/v3/ActionTranslator.g:1:481: TEMPLATE_EXPR
+ {
+ mTEMPLATE_EXPR(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred22_ActionTranslator
+
+ // $ANTLR start synpred24_ActionTranslator
+ public final void synpred24_ActionTranslator_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionTranslator.g:1:499: ( ERROR_XY )
+ // org/antlr/grammar/v3/ActionTranslator.g:1:499: ERROR_XY
+ {
+ mERROR_XY(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred24_ActionTranslator
+
+ // $ANTLR start synpred25_ActionTranslator
+ public final void synpred25_ActionTranslator_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionTranslator.g:1:508: ( ERROR_X )
+ // org/antlr/grammar/v3/ActionTranslator.g:1:508: ERROR_X
+ {
+ mERROR_X(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred25_ActionTranslator
+
+ // $ANTLR start synpred26_ActionTranslator
+ public final void synpred26_ActionTranslator_fragment() throws RecognitionException {
+ // org/antlr/grammar/v3/ActionTranslator.g:1:516: ( UNKNOWN_SYNTAX )
+ // org/antlr/grammar/v3/ActionTranslator.g:1:516: UNKNOWN_SYNTAX
+ {
+ mUNKNOWN_SYNTAX(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred26_ActionTranslator
+
+ public final boolean synpred18_ActionTranslator() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred18_ActionTranslator_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred19_ActionTranslator() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred19_ActionTranslator_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred16_ActionTranslator() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred16_ActionTranslator_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred11_ActionTranslator() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred11_ActionTranslator_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred24_ActionTranslator() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred24_ActionTranslator_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred12_ActionTranslator() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred12_ActionTranslator_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred9_ActionTranslator() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred9_ActionTranslator_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred17_ActionTranslator() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred17_ActionTranslator_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred4_ActionTranslator() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred4_ActionTranslator_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred13_ActionTranslator() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred13_ActionTranslator_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred21_ActionTranslator() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred21_ActionTranslator_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred20_ActionTranslator() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred20_ActionTranslator_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred6_ActionTranslator() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred6_ActionTranslator_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred2_ActionTranslator() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred2_ActionTranslator_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred3_ActionTranslator() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred3_ActionTranslator_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred10_ActionTranslator() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred10_ActionTranslator_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred5_ActionTranslator() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred5_ActionTranslator_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred14_ActionTranslator() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred14_ActionTranslator_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred25_ActionTranslator() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred25_ActionTranslator_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred26_ActionTranslator() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred26_ActionTranslator_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred7_ActionTranslator() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred7_ActionTranslator_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred1_ActionTranslator() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred1_ActionTranslator_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred22_ActionTranslator() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred22_ActionTranslator_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred8_ActionTranslator() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred8_ActionTranslator_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred15_ActionTranslator() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred15_ActionTranslator_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+
+
+ protected DFA22 dfa22 = new DFA22(this);
+ protected DFA28 dfa28 = new DFA28(this);
+ static final String DFA22_eotS =
+ "\1\1\11\uffff";
+ static final String DFA22_eofS =
+ "\12\uffff";
+ static final String DFA22_minS =
+ "\1\42\11\uffff";
+ static final String DFA22_maxS =
+ "\1\175\11\uffff";
+ static final String DFA22_acceptS =
+ "\1\uffff\1\11\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10";
+ static final String DFA22_specialS =
+ "\12\uffff}>";
+ static final String[] DFA22_transitionS = {
+ "\1\11\5\uffff\1\4\1\5\2\uffff\1\6\1\uffff\1\3\22\uffff\32\2"+
+ "\4\uffff\1\2\1\uffff\32\2\1\7\1\uffff\1\10",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] DFA22_eot = DFA.unpackEncodedString(DFA22_eotS);
+ static final short[] DFA22_eof = DFA.unpackEncodedString(DFA22_eofS);
+ static final char[] DFA22_min = DFA.unpackEncodedStringToUnsignedChars(DFA22_minS);
+ static final char[] DFA22_max = DFA.unpackEncodedStringToUnsignedChars(DFA22_maxS);
+ static final short[] DFA22_accept = DFA.unpackEncodedString(DFA22_acceptS);
+ static final short[] DFA22_special = DFA.unpackEncodedString(DFA22_specialS);
+ static final short[][] DFA22_transition;
+
+ static {
+ int numStates = DFA22_transitionS.length;
+ DFA22_transition = new short[numStates][];
+ for (int i=0; i<numStates; i++) {
+ DFA22_transition[i] = DFA.unpackEncodedString(DFA22_transitionS[i]);
+ }
+ }
+
+ class DFA22 extends DFA {
+
+ public DFA22(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 22;
+ this.eot = DFA22_eot;
+ this.eof = DFA22_eof;
+ this.min = DFA22_min;
+ this.max = DFA22_max;
+ this.accept = DFA22_accept;
+ this.special = DFA22_special;
+ this.transition = DFA22_transition;
+ }
+ public String getDescription() {
+ return "()* loopback of 786:8: ( ID | '.' | '(' | ')' | ',' | '{' | '}' | '\"' )*";
+ }
+ }
+ static final String DFA28_eotS =
+ "\36\uffff";
+ static final String DFA28_eofS =
+ "\36\uffff";
+ static final String DFA28_minS =
+ "\1\0\1\uffff\1\0\6\uffff\1\0\24\uffff";
+ static final String DFA28_maxS =
+ "\1\uffff\1\uffff\1\0\6\uffff\1\0\24\uffff";
+ static final String DFA28_acceptS =
+ "\1\uffff\1\33\1\uffff\1\22\1\23\1\24\1\25\1\26\1\32\1\uffff\1\1"+
+ "\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1\15\1\16\1\17"+
+ "\1\20\1\21\1\30\1\31\1\27";
+ static final String DFA28_specialS =
+ "\1\0\1\uffff\1\1\6\uffff\1\2\24\uffff}>";
+ static final String[] DFA28_transitionS = {
+ "\44\1\1\11\1\2\66\1\1\35\uffa3\1",
+ "",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] DFA28_eot = DFA.unpackEncodedString(DFA28_eotS);
+ static final short[] DFA28_eof = DFA.unpackEncodedString(DFA28_eofS);
+ static final char[] DFA28_min = DFA.unpackEncodedStringToUnsignedChars(DFA28_minS);
+ static final char[] DFA28_max = DFA.unpackEncodedStringToUnsignedChars(DFA28_maxS);
+ static final short[] DFA28_accept = DFA.unpackEncodedString(DFA28_acceptS);
+ static final short[] DFA28_special = DFA.unpackEncodedString(DFA28_specialS);
+ static final short[][] DFA28_transition;
+
+ static {
+ int numStates = DFA28_transitionS.length;
+ DFA28_transition = new short[numStates][];
+ for (int i=0; i<numStates; i++) {
+ DFA28_transition[i] = DFA.unpackEncodedString(DFA28_transitionS[i]);
+ }
+ }
+
+ class DFA28 extends DFA {
+
+ public DFA28(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 28;
+ this.eot = DFA28_eot;
+ this.eof = DFA28_eof;
+ this.min = DFA28_min;
+ this.max = DFA28_max;
+ this.accept = DFA28_accept;
+ this.special = DFA28_special;
+ this.transition = DFA28_transition;
+ }
+ public String getDescription() {
+ return "1:1: Tokens options {k=1; backtrack=true; } : ( SET_ENCLOSING_RULE_SCOPE_ATTR | ENCLOSING_RULE_SCOPE_ATTR | SET_TOKEN_SCOPE_ATTR | TOKEN_SCOPE_ATTR | SET_RULE_SCOPE_ATTR | RULE_SCOPE_ATTR | LABEL_REF | ISOLATED_TOKEN_REF | ISOLATED_LEXER_RULE_REF | SET_LOCAL_ATTR | LOCAL_ATTR | SET_DYNAMIC_SCOPE_ATTR | DYNAMIC_SCOPE_ATTR | ERROR_SCOPED_XY | DYNAMIC_NEGATIVE_INDEXED_SCOPE_ATTR | DYNAMIC_ABSOLUTE_INDEXED_SCOPE_ATTR | ISOLATED_DYNAMIC_SCOPE | TEMPLATE_INSTANCE | INDIRECT [...]
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ IntStream input = _input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA28_0 = input.LA(1);
+
+ s = -1;
+ if ( ((LA28_0>='\u0000' && LA28_0<='#')||(LA28_0>='&' && LA28_0<='[')||(LA28_0>=']' && LA28_0<='\uFFFF')) ) {s = 1;}
+
+ else if ( (LA28_0=='%') ) {s = 2;}
+
+ else if ( (LA28_0=='$') ) {s = 9;}
+
+ else if ( (LA28_0=='\\') ) {s = 29;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA28_2 = input.LA(1);
+
+
+ int index28_2 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred18_ActionTranslator()) ) {s = 3;}
+
+ else if ( (synpred19_ActionTranslator()) ) {s = 4;}
+
+ else if ( (synpred20_ActionTranslator()) ) {s = 5;}
+
+ else if ( (synpred21_ActionTranslator()) ) {s = 6;}
+
+ else if ( (synpred22_ActionTranslator()) ) {s = 7;}
+
+ else if ( (synpred26_ActionTranslator()) ) {s = 8;}
+
+
+ input.seek(index28_2);
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA28_9 = input.LA(1);
+
+
+ int index28_9 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred1_ActionTranslator()) ) {s = 10;}
+
+ else if ( (synpred2_ActionTranslator()) ) {s = 11;}
+
+ else if ( (synpred3_ActionTranslator()) ) {s = 12;}
+
+ else if ( (synpred4_ActionTranslator()) ) {s = 13;}
+
+ else if ( (synpred5_ActionTranslator()) ) {s = 14;}
+
+ else if ( (synpred6_ActionTranslator()) ) {s = 15;}
+
+ else if ( (synpred7_ActionTranslator()) ) {s = 16;}
+
+ else if ( (synpred8_ActionTranslator()) ) {s = 17;}
+
+ else if ( (synpred9_ActionTranslator()) ) {s = 18;}
+
+ else if ( (synpred10_ActionTranslator()) ) {s = 19;}
+
+ else if ( (synpred11_ActionTranslator()) ) {s = 20;}
+
+ else if ( (synpred12_ActionTranslator()) ) {s = 21;}
+
+ else if ( (synpred13_ActionTranslator()) ) {s = 22;}
+
+ else if ( (synpred14_ActionTranslator()) ) {s = 23;}
+
+ else if ( (synpred15_ActionTranslator()) ) {s = 24;}
+
+ else if ( (synpred16_ActionTranslator()) ) {s = 25;}
+
+ else if ( (synpred17_ActionTranslator()) ) {s = 26;}
+
+ else if ( (synpred24_ActionTranslator()) ) {s = 27;}
+
+ else if ( (synpred25_ActionTranslator()) ) {s = 28;}
+
+ else if ( (synpred26_ActionTranslator()) ) {s = 8;}
+
+
+ input.seek(index28_9);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 28, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+
+}
\ No newline at end of file
diff --git a/debian/maven.bootstrap.ignoreRules b/debian/maven.bootstrap.ignoreRules
new file mode 100644
index 0000000..a4dd2db
--- /dev/null
+++ b/debian/maven.bootstrap.ignoreRules
@@ -0,0 +1,26 @@
+# Maven ignore rules - ignore some Maven dependencies and plugins
+# Format of this file is:
+# [group] [artifact] [type] [version]
+# where each element can be either
+# - the exact string, for example org.apache for the group, or 3.1
+# for the version. In this case, the element is simply matched
+# and left as it is
+# - * (the star character, alone). In this case, anything will
+# match and be left as it is. For example, using * on the
+# position of the artifact field will match any artifact id
+# All elements much match before a rule can be applied
+# Example rule: match jar with groupid= junit, artifactid= junit
+# and version starting with 3., this dependency is then removed
+# from the POM
+# junit junit jar s/3\..*/3.x/
+org.antlr gunit jar *
+org.antlr maven-gunit-plugin maven-plugin *
+org.apache.maven.plugins maven-assembly-plugin maven-plugin *
+org.apache.maven.plugins maven-project-info-reports-plugin maven-plugin *
+org.apache.maven.plugins maven-site-plugin maven-plugin *
+org.apache.maven.wagon wagon-ssh-external jar *
+org.codehaus.mojo buildnumber-maven-plugin maven-plugin *
+org.codehaus.mojo findbugs-maven-plugin maven-plugin *
+org.antlr antlr3-maven-plugin maven-plugin *
+
+
diff --git a/debian/maven.cleanIgnoreRules b/debian/maven.cleanIgnoreRules
new file mode 100644
index 0000000..866a6a1
--- /dev/null
+++ b/debian/maven.cleanIgnoreRules
@@ -0,0 +1,16 @@
+# Maven clean ignore rules - ignore some Maven dependencies and plugins during the clean phase
+# Format of this file is:
+# [group] [artifact] [type] [version]
+# where each element can be either
+# - the exact string, for example org.apache for the group, or 3.1
+# for the version. In this case, the element is simply matched
+# and left as it is
+# - * (the star character, alone). In this case, anything will
+# match and be left as it is. For example, using * on the
+# position of the artifact field will match any artifact id
+# All elements much match before a rule can be applied
+# Example rule: match jar with groupid= junit, artifactid= junit
+# and version starting with 3., this dependency is then removed
+# from the POM
+# junit junit jar s/3\..*/3.x/
+org.antlr antlr3-maven-plugin maven-plugin *
diff --git a/debian/maven.ignoreRules b/debian/maven.ignoreRules
new file mode 100644
index 0000000..1f2476e
--- /dev/null
+++ b/debian/maven.ignoreRules
@@ -0,0 +1,21 @@
+# Maven ignore rules - ignore some Maven dependencies and plugins
+# Format of this file is:
+# [group] [artifact] [type] [version]
+# where each element can be either
+# - the exact string, for example org.apache for the group, or 3.1
+# for the version. In this case, the element is simply matched
+# and left as it is
+# - * (the star character, alone). In this case, anything will
+# match and be left as it is. For example, using * on the
+# position of the artifact field will match any artifact id
+# All elements much match before a rule can be applied
+# Example rule: match jar with groupid= junit, artifactid= junit
+# and version starting with 3., this dependency is then removed
+# from the POM
+# junit junit jar s/3\..*/3.x/
+org.apache.maven.plugins maven-assembly-plugin maven-plugin *
+org.apache.maven.plugins maven-project-info-reports-plugin maven-plugin *
+org.apache.maven.wagon wagon-ssh-external jar *
+org.codehaus.mojo buildnumber-maven-plugin maven-plugin *
+org.codehaus.mojo findbugs-maven-plugin maven-plugin *
+
diff --git a/debian/maven.properties b/debian/maven.properties
new file mode 100644
index 0000000..d21ac6f
--- /dev/null
+++ b/debian/maven.properties
@@ -0,0 +1,4 @@
+# Include here properties to pass to Maven during the build.
+# For example:
+# maven.test.skip=true
+maven.test.skip=true
diff --git a/debian/maven.publishedRules b/debian/maven.publishedRules
new file mode 100644
index 0000000..fdca377
--- /dev/null
+++ b/debian/maven.publishedRules
@@ -0,0 +1,18 @@
+# Maven published rules - additional rules to publish, to help
+# the packaging work of Debian maintainers using mh_make
+# Format of this file is:
+# [group] [artifact] [type] [version]
+# where each element can be either
+# - the exact string, for example org.apache for the group, or 3.1
+# for the version. In this case, the element is simply matched
+# and left as it is
+# - * (the star character, alone). In this case, anything will
+# match and be left as it is. For example, using * on the
+# position of the artifact field will match any artifact id
+# - a regular expression of the form s/match/replace/
+# in this case, elements that match are transformed using
+# the regex rule.
+# All elements much match before a rule can be applied
+# Example rule: match any dependency whose group is ant,
+# replacing it with org.apache.ant
+# s/ant/org.apache.ant/ * * s/.*/debian/
diff --git a/debian/maven.rules b/debian/maven.rules
new file mode 100644
index 0000000..2729eef
--- /dev/null
+++ b/debian/maven.rules
@@ -0,0 +1,27 @@
+# Maven rules - transform Maven dependencies and plugins
+# Format of this file is:
+# [group] [artifact] [type] [version]
+# where each element can be either
+# - the exact string, for example org.apache for the group, or 3.1
+# for the version. In this case, the element is simply matched
+# and left as it is
+# - * (the star character, alone). In this case, anything will
+# match and be left as it is. For example, using * on the
+# position of the artifact field will match any artifact id
+# - a regular expression of the form s/match/replace/
+# in this case, elements that match are transformed using
+# the regex rule.
+# All elements much match before a rule can be applied
+# Example rule: match jar with groupid= junit, artifactid= junit
+# and version starting with 3., replacing the version with 3.x
+# junit junit jar s/3\..*/3.x/
+antlr antlr jar s/2\..*/2.x/ *
+junit junit jar s/4\..*/4.x/ *
+org.antlr stringtemplate jar s/3\..*/3.x/ *
+# TODO: update this version when there is a new upstream version of antlr3
+org.antlr antlr3-maven-plugin maven-plugin s/.*/3.2/
+s/org.apache.maven.shared/org.apache.maven.plugin-testing/ maven-plugin-testing * s/.*/debian/ *
+s/org.apache.maven.shared/org.apache.maven.plugin-testing/ maven-plugin-testing-harness * s/.*/debian/ *
+s/org.apache.maven.shared/org.apache.maven.plugin-testing/ maven-plugin-testing-tools * s/.*/debian/ *
+s/org.apache.maven.shared/org.apache.maven.plugin-testing/ maven-test-tools * s/.*/debian/ *
+
diff --git a/debian/orig-tar.sh b/debian/orig-tar.sh
new file mode 100755
index 0000000..48652ce
--- /dev/null
+++ b/debian/orig-tar.sh
@@ -0,0 +1,20 @@
+#!/bin/sh -e
+
+TAR=../antlr3_$2.orig.tar.gz
+DIR=antlr-$2
+ORIG_TAR=$3
+
+tar -x -z -v -f $ORIG_TAR
+
+find $DIR -name ".*" -exec rm '{}' \;
+rm -f $TAR
+tar -c -z -f $TAR $DIR
+rm -rf $DIR
+
+# move to directory 'tarballs'
+if [ -r .svn/deb-layout ]; then
+ . .svn/deb-layout
+ mv $TAR $origDir
+ echo "moved $TAR to $origDir"
+fi
+
diff --git a/debian/patches/antlr3-build_xml.patch b/debian/patches/antlr3-build_xml.patch
deleted file mode 100644
index dd6e13d..0000000
--- a/debian/patches/antlr3-build_xml.patch
+++ /dev/null
@@ -1,40 +0,0 @@
---- antlr3-3.0.1+dfsg.orig/build.xml
-+++ antlr3-3.0.1+dfsg/build.xml
-@@ -33,11 +33,17 @@
-
- <path id="src.path">
- <pathelement location="${src.dir}" />
-+ <!--
- <pathelement location="${codegen.dir}" />
-+ -->
- </path>
-
- <path id="rt.classpath">
-+ <!--
- <fileset dir="${lib.dir}" includes="**/*.jar" />
-+ -->
-+ <pathelement location="/usr/share/java/antlr.jar" />
-+ <pathelement location="/usr/share/java/stringtemplate.jar" />
- </path>
-
- <path id="classpath">
-@@ -61,6 +67,7 @@
- debuglevel="${compile.debuglevel}"
- deprecation="${compile.deprecation}"
- optimize="${compile.optimize}"
-+ nowarn="true"
- source="1.5" target="jsr14" />
- </presetdef>
-
-@@ -114,6 +121,11 @@
- </target>
-
- <target name="compile" depends="generator,compile-rt">
-+ <!--
-+ <copy todir="${src.dir}/org/antlr/tool">
-+ <fileset dir="${codegen.dir}" includes="*.java" excludes="CodeGenTree*.java" />
-+ </copy>
-+ -->
- <mkdir dir="${build.classes}" />
- <myjavac destdir="${build.classes}" classpathref="classpath">
- <src refid="src.path" />
diff --git a/debian/rules b/debian/rules
index 2a1fc82..cc47fb3 100755
--- a/debian/rules
+++ b/debian/rules
@@ -1,29 +1,47 @@
#!/usr/bin/make -f
-include /usr/share/cdbs/1/class/ant.mk
+# Uncomment this to turn on verbose mode.
+#export DH_VERBOSE=1
+
include /usr/share/cdbs/1/rules/debhelper.mk
-include /usr/share/cdbs/1/rules/simple-patchsys.mk
+include /usr/share/cdbs/1/class/maven.mk
+include /usr/share/cdbs/1/rules/patchsys-quilt.mk
-include /usr/share/gcj/debian_defaults
+#include /usr/share/gcj/debian_defaults
-DEB_HOST_ARCH ?= $(shell dpkg-architecture -qDEB_HOST_ARCH)
-ifneq (,$(filter $(DEB_HOST_ARCH), $(gcj_native_archs)))
- with_native := yes
-endif
+#DEB_HOST_ARCH ?= $(shell dpkg-architecture -qDEB_HOST_ARCH)
+#ifneq (,$(filter $(DEB_HOST_ARCH), $(gcj_native_archs)))
+# with_native := yes
+#endif
-JAVA_HOME := /usr/lib/jvm/default-java
-ANT_OPTS = -Dant.build.javac.source=1.4
-DEB_JARS := ant-antlr antlr junit
+DEB_MAVEN_INSTALL_TO_USJ := false
+DEB_MAVEN_DOC_TARGET := javadoc:jar javadoc:aggregate
+PACKAGE := $(DEB_SOURCE_PACKAGE)
+VERSION := $(shell echo $(DEB_UPSTREAM_VERSION) | cut -d'+' -f1 -)
+JAVA_HOME := /usr/lib/jvm/default-java
+DEB_MAVEN_ARGS := -DbuildNumber="debian-$(shell echo $(DEB_NOEPOCH_VERSION) | sed 's/.*-//')"
-build/antlr3::
- install -m 644 -D build/antlr.jar \
- debian/antlr3/usr/share/java/antlr3-$(DEB_UPSTREAM_VERSION).jar
- dh_link -pantlr3 /usr/share/java/antlr3-$(DEB_UPSTREAM_VERSION).jar \
- /usr/share/java/antlr3.jar
+# Bootstrap the build with the generated sources taken from a normal run of
+# mvn install on the Antlr source code
+before-mvn-build:: PLUGIN_ARGS += -Dmaven.test.skip=true -Duse.maven.repo.local=true
+before-mvn-build::
+ cp -r debian/generated-sources/antlr3/* tool/src/main/java
+ mh_patchpoms -pantlr3 --debian-build --keep-pom-version -idebian/maven.bootstrap.ignoreRules --maven-repo=$(DEB_MAVEN_REPO)
+ $(DEB_MAVEN_INVOKE) $(PLUGIN_ARGS) -N $(DEB_MAVEN_BUILD_TARGET) $(DEB_MAVEN_INSTALL_TARGET)
+ cd runtime/Java && $(DEB_MAVEN_INVOKE) $(PLUGIN_ARGS) $(DEB_MAVEN_BUILD_TARGET) $(DEB_MAVEN_INSTALL_TARGET)
+ cd tool && $(DEB_MAVEN_INVOKE) $(PLUGIN_ARGS) $(DEB_MAVEN_BUILD_TARGET) $(DEB_MAVEN_INSTALL_TARGET)
+ cd antlr3-maven-plugin && $(DEB_MAVEN_INVOKE) $(PLUGIN_ARGS) $(DEB_MAVEN_BUILD_TARGET) $(DEB_MAVEN_INSTALL_TARGET)
+ rm -rf tool/src/main/java/*.tokens
+ rm -rf tool/src/main/java/org/antlr/grammar/v3
+ mh_unpatchpoms -pantlr3
+
+binary-post-install/antlr3::
+ mh_linkrepojar -pantlr3 runtime/Java/pom.xml /usr/share/java/antlr3-runtime.jar
+ mh_linkrepojar -pantlr3 tool/pom.xml /usr/share/java/antlr3.jar
binary-post-install/antlr3-gcj:: binary-post-install/antlr3
[ -f debian/antlr3/usr/share/java/antlr3-$(DEB_UPSTREAM_VERSION).jar ] \
- || install -m 644 -D build/antlr.jar \
+ || install -m 644 -D tool/target/antlr-$(DEB_UPSTREAM_VERSION).jar \
debian/antlr3/usr/share/java/antlr3-$(DEB_UPSTREAM_VERSION).jar
rm -rf debian/antlr3-gcj/usr/share/doc/antlr3-gcj
ln -s antlr3 \
@@ -31,3 +49,6 @@ binary-post-install/antlr3-gcj:: binary-post-install/antlr3
ifeq ($(with_native),yes)
dh_nativejava -pantlr3-gcj
endif
+
+get-orig-source:
+ -uscan --download-version $(DEB_UPSTREAM_VERSION) --force-download --rename --repack
diff --git a/debian/source/format b/debian/source/format
new file mode 100644
index 0000000..163aaf8
--- /dev/null
+++ b/debian/source/format
@@ -0,0 +1 @@
+3.0 (quilt)
diff --git a/debian/watch b/debian/watch
index 8fe9077..d8b402c 100644
--- a/debian/watch
+++ b/debian/watch
@@ -1,3 +1,2 @@
version=3
-opts=uversionmangle=s/rc\d//,dversionmangle=s/\+dfsg// \
-http://www.antlr.org/download/ .*antlr-(.*)\.tar\.gz debian uupdate
+http://www.antlr.org/download/ /antlr-(.*)\.tar\.gz debian debian/orig-tar.sh
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-java/antlr3.2.git
More information about the pkg-java-commits
mailing list