[jboss-svn-commits] JBL Code SVN: r23007 - in labs/jbosstm/workspace/adinn/orchestration: dd/grammar and 5 other directories.
jboss-svn-commits at lists.jboss.org
jboss-svn-commits at lists.jboss.org
Tue Sep 23 06:27:03 EDT 2008
Author: adinn
Date: 2008-09-23 06:27:03 -0400 (Tue, 23 Sep 2008)
New Revision: 23007
Added:
labs/jbosstm/workspace/adinn/orchestration/handler.txt
labs/jbosstm/workspace/adinn/orchestration/src/TestScript.java
labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/expression/BooleanLiteral.java
Modified:
labs/jbosstm/workspace/adinn/orchestration/README
labs/jbosstm/workspace/adinn/orchestration/build.xml
labs/jbosstm/workspace/adinn/orchestration/dd/grammar/ECAGrammar.g
labs/jbosstm/workspace/adinn/orchestration/dd/grammar/ECAToken.g
labs/jbosstm/workspace/adinn/orchestration/src/TestJar.java
labs/jbosstm/workspace/adinn/orchestration/src/TestRule.java
labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/agent/Main.java
labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/agent/Transformer.java
labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/Action.java
labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/Condition.java
labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/Rule.java
labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/expression/ExpressionHelper.java
labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/grammar/ECAGrammarParser.java
labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/grammar/ECATokenLexer.java
Log:
switched to using test rule scripts instead of annotations. added more rules to test scenario to improve readability and clean up. enabled comments in scripts using # prefix
Modified: labs/jbosstm/workspace/adinn/orchestration/README
===================================================================
--- labs/jbosstm/workspace/adinn/orchestration/README 2008-09-23 08:42:24 UTC (rev 23006)
+++ labs/jbosstm/workspace/adinn/orchestration/README 2008-09-23 10:27:03 UTC (rev 23007)
@@ -1,7 +1,8 @@
Type 'ant jar' to create the orchestration package library which
supports definition of Event Condition Action rules for orchestrating
JBossTS test scenarios via insertion of event triggers into com.arjuna
-methods, either at start of method code or at specific line numbers.
+or org.jboss methods, either at start of method code or at specific
+line numbers.
Set up
------
@@ -22,31 +23,56 @@
The agent is passed to the JVM using the -javaagent option of the java
command by setting JAVA_OPTS as follows:
-export JAVA_OPTS="-javaagent:${HOME}/jboss/workspace/adinn/orchestration/build/lib/orchestration.jar=rule:${HOME}/jboss/workspace/adinn/orchestration/build/lib/orchestration.jar"
+export JAVA_OPTS="-javaagent:${HOME}/jboss/workspace/adinn/orchestration/build/lib/orchestration.jar=script:${HOME}/jboss/workspace/adinn/orchestration/handler.txt"
-The =rule:<jar> option to the -javaagent argument tells the agent
-premain to search <jar> for rules, i.e. classes and methods annotated
-with, respectively, EventHandlerClass and EventHandler
-annotations. The agent will parse them to identify rules for
-transforming com.arjuna.* classes. The agent jar contains a simple
-test class, org.jboss.jbossts.test.HandlerClass, which defines 4 rules
-used for testing a specific scenario in XTS coordinator crash
+The =script:<scriptFile> option to the -javaagent argument tells the
+agent premain to search <scriptFile> for rules. Multiple scripts may
+be supplied by repeating the =script:<scriptFile> argument separated
+by a ','. The agent will parse each script file to identify rules to
+be triggered from methods occurring in com.arjuna.* and org.jboss.*
+classes. File handler.txt contains an example script which defines 6
+rules used for testing a specific scenario in XTS coordinator crash
recovery. See these (or the code :-) to get a taste of what the rule
language offers (that's all foax, for now at least -- sorry).
Rule Definition
---------------
-Rules are defined via class and method anotations on a host class. Any
-class tagged with an EventHandlerClass annotation is a host class and
-is able to define a set of rules. Any static method of a host class
-annotated with an EventHandler annotation defines an individual
-rule. The EventHandler annotation must define a target class for the
-rule, a target method and a target method line number (or -1 for start
-of method). Text elements in the annotation specify the rule event,
-condition and action. The event handler class and event handler static
-method code are available for use in the rule but they need not be
-invoked.
+The orchestration package employs Event Condition Action rules
+although, strictly, the event component is limited to matching an
+invocation of a specific method when execution reaches a particular
+soure code line number in the method body. The event automatically
+binds the arguments of the trigger method at the point where the rule
+is triggered. It may also compute bindings for an optional set of
+local variables by evaluating a Java expression. The condition is an
+expression with boolean type. The action is a sequence of expressions
+of arbitrary type which are only evaluated if the condition is
+true. Expressions are composed from builtin operations, references to
+static or bound values, method invocations and combinations of
+sub-expressions using the usual set of operators. Note that
+assignment, new operations and throw operations are not allowed in
+expressions.
+
+Rule definitiosn specify a target class, a target method and a target
+line number (default is -1) in the method source code. The agent code
+identifies classes and methods at load time which match the target
+class and name and inserts a trigger call at the specified line which
+invokes the rule (or at the method start if the line number is
+-1). When execution reaches a trigger point the associated rule is
+executed and can performs any delay, synchronization, trace or other
+operation appropriate to the test. Normally, control returns to the
+trigger method and execution continues by executing the target line.
+
+It is possible for a rule to alter the flow of control. A rule action
+can invoke a builtin to 'kill' the current thread, by throwing a
+runtime exception. This may not actually kill the thread if the
+trigger method code or one of its callers catches a generic exception
+but it can be used effectively. Another builtin can be used to signal
+other waiting threads and cause them to 'abort'. Finally, a third
+builtin allows the JVM to be halted. It is possible to call arbitrary
+Java code inside rule actions so the opportunites for messing around
+with control flow extend beyond these builtin options.
+
The target class may be specified with or without a full package
qualification. If no package is specified then all classes whose
unqualified name equals the target will be candidiates for rule
@@ -56,29 +82,36 @@
implementation classes in the JTA, JTS and XTS packages but would not
match any org.jboss implementations.
-Note that a rule is deliberately not defined using the host class code
-(the class tagged with annotation EventHandlerClass). It is quite
-legitimate to call host class methods from within a rule event,
-condition or action but they cannot provide the complete definition of
-the rule itself. Rules need to refer to the target class and,
-possibly, classes that it references. Defining the rule via the host
-class implementation would impose recursive class loader dependencies
-between the host class and the class into which it is trying to insert
-trigger code.
+Class names mentioned in rules are resolved against a candidate
+trigger class and related classes at runtime as they are being loaded
+into a specific class loader. If the type checker cannot resolve the
+declared types of variables, methods and fields mentioned in the rule
+against candidate classes it prints type check errors and disables
+execution of the rule for the class in question. Note that if a class
+is loaded more than once by different class loaders then each version
+of the class may be a candidate for trigger insertion from the same
+rule. Use of unqualified class names (i.e. without package) also
+potentially allows a rule to be applied in more than one case.
-Note also that classes mentioned in the rule are only identified by
-name. Such names are resolved at runtime against a target class and
-related classes as they are being loaded into a specific class
-loader. So, if a class is loaded more than once then each version of
-the class may be a candidate for trigger insertion. As a consequence,
-class names emloyed in rules may also be quoted without package
-qualification. However, it must be possible for the rule compiler to
-translate them unambiguously to fully qualified class names by
-inferring the types from the target class and target method signature
-identified at transform time or by deriving them from field references
-and method signatures of classes associated with the target class and
-method.
+Method names may be specified using just the method name or by
+supplying the name and a bracketed list of parameters, optionally
+followed by a return type. If just the name is specified then any
+method with the correct name will be considered as a candidate for
+trigger insertion. Again, this allows the rule to be applied to
+multiple cases (this is only really useful if the line number is -1).
+If a signature is provided then the trigger call will only be inserted
+into a method whose arguments match the signature. The types employed
+in a signature may also omit the package name if desired.
+Note that a rule is deliberately defined via a script rather than
+using annotations, especially not annotations on the trigger class.
+Rules refer to the target class and, possibly, classes that it
+references by name only. Defining the rule via annotations on the
+target class implementation would require loading the class before
+having the chance to modify its byte code. Also, the point of using
+rules is so that tests may be rigged up without having to redefine and
+rebuild the test code base.
+
Rule Events
-----------
An event specification is a list of bindings for variables which can
@@ -89,7 +122,7 @@
static) and $1...$N for arguments 1..N of the target method. Further
bindings, using symbolic names for the bound variables, can be
established by assigning a symbolic constant to an expression which
-may refer to previously bound variables. For example,
+may refer to previously bound variables or static data. For example,
'coordinator:Coordinator = $0,
recovered:boolean = coordinator.recovered,
Modified: labs/jbosstm/workspace/adinn/orchestration/build.xml
===================================================================
--- labs/jbosstm/workspace/adinn/orchestration/build.xml 2008-09-23 08:42:24 UTC (rev 23006)
+++ labs/jbosstm/workspace/adinn/orchestration/build.xml 2008-09-23 10:27:03 UTC (rev 23007)
@@ -135,7 +135,7 @@
<target name="TestParse.compile">
<!-- build the TestParse class and then run it to check parsing of rule elements -->
- <javac srcdir="${src.dir}" destdir="${build.classes.dir}" debug="${javac.debug}" source="TestParse.java">
+ <javac srcdir="${src.dir}" destdir="${build.classes.dir}" debug="${javac.debug}" includes="TestParse.java">
<classpath>
<pathelement location="${asm.home}/${asm.jar}"/>
<fileset dir="${ext.lib.dir}" includes="${ext.antlr.jars}"/>
@@ -158,7 +158,7 @@
<target name="TestRule.compile">
<!-- build the TestRule class and then run it to check parsing of rule elements -->
- <javac srcdir="${src.dir}" destdir="${build.classes.dir}" debug="${javac.debug}" source="TestRule.java">
+ <javac srcdir="${src.dir}" destdir="${build.classes.dir}" debug="${javac.debug}" includes="TestRule.java">
<classpath>
<pathelement location="${asm.home}/${asm.jar}"/>
<fileset dir="${ext.lib.dir}" includes="${ext.antlr.jars}"/>
@@ -314,7 +314,7 @@
<target name="TestJar.compile">
<!-- build the TestJar class and then run it to check parsing of rule elements -->
- <javac srcdir="${src.dir}" destdir="${build.classes.dir}" debug="${javac.debug}" source="TestJar.java">
+ <javac srcdir="${src.dir}" destdir="${build.classes.dir}" debug="${javac.debug}" includes="TestJar.java">
<classpath>
<pathelement location="${asm.home}/${asm.jar}"/>
<fileset dir="${ext.lib.dir}" includes="${ext.antlr.jars}"/>
@@ -360,4 +360,52 @@
</java>
</target>
+ <target name="TestScript.compile">
+ <!-- build the TestScript class and then run it to check parsing of rule elements -->
+ <javac srcdir="${src.dir}" destdir="${build.classes.dir}" debug="${javac.debug}" includes="TestScript.java">
+ <classpath>
+ <pathelement location="${asm.home}/${asm.jar}"/>
+ <fileset dir="${ext.lib.dir}" includes="${ext.antlr.jars}"/>
+ </classpath>
+ </javac>
+ </target>
+
+ <target name="TestScript" depends="TestScript.compile">
+ <java classname="TestScript" fork="true">
+ <classpath>
+ <fileset dir="${build.lib.dir}" includes="orchestration.jar"/>
+ <pathelement location="${asm.home}/${asm.jar}"/>
+ <fileset dir="${ext.lib.dir}" includes="${ext.antlr.jars}"/>
+ <!-- xts, jta and jboss as jars-->
+ <fileset dir="${xts.lib.dir}" includes="${xts.lib.jars}"/>
+ <fileset dir="${xts.sar.dir}" includes="${xts.sar.jars}"/>
+ <fileset dir="${jboss.lib.dir}" includes="${jboss.lib.jars}"/>
+ <fileset dir="${jboss.client.dir}" includes="${jboss.client.jars}"/>
+ <fileset dir="${jboss.server.lib.dir}" includes="${jboss.server.lib.jars}"/>
+ <fileset dir="${jboss.server.deploy.dir}" includes="${jboss.server.deploy.jars}"/>
+ </classpath>
+ <arg value="handler.txt"/>
+ </java>
+ </target>
+
+ <target name="TestScriptDebug" depends="TestScript.compile">
+ <java classname="TestScript" fork="true">
+ <classpath>
+ <fileset dir="${build.lib.dir}" includes="orchestration.jar"/>
+ <pathelement location="${asm.home}/${asm.jar}"/>
+ <fileset dir="${ext.lib.dir}" includes="${ext.antlr.jars}"/>
+ <!-- xts, jta and jboss as jars-->
+ <fileset dir="${xts.lib.dir}" includes="${xts.lib.jars}"/>
+ <fileset dir="${xts.sar.dir}" includes="${xts.sar.jars}"/>
+ <fileset dir="${jboss.lib.dir}" includes="${jboss.lib.jars}"/>
+ <fileset dir="${jboss.client.dir}" includes="${jboss.client.jars}"/>
+ <fileset dir="${jboss.server.lib.dir}" includes="${jboss.server.lib.jars}"/>
+ <fileset dir="${jboss.server.deploy.dir}" includes="${jboss.server.deploy.jars}"/>
+ </classpath>
+ <jvmarg value="-Xdebug"/>
+ <jvmarg value="-Xrunjdwp:transport=dt_socket,server=n,address=5005,suspend=y"/>
+ <arg value="handler.txt"/>
+ </java>
+ </target>
+
</project>
Modified: labs/jbosstm/workspace/adinn/orchestration/dd/grammar/ECAGrammar.g
===================================================================
--- labs/jbosstm/workspace/adinn/orchestration/dd/grammar/ECAGrammar.g 2008-09-23 08:42:24 UTC (rev 23006)
+++ labs/jbosstm/workspace/adinn/orchestration/dd/grammar/ECAGrammar.g 2008-09-23 10:27:03 UTC (rev 23007)
@@ -23,6 +23,18 @@
package org.jboss.jbossts.orchestration.rule.grammar;
}
+eca_script_rule : rule=eca_script_rule_one EOF -> ^($rule)
+ ;
+eca_script_rule_one
+ : RULE n=SYMBOL
+ CLASS cl=SYMBOL
+ METHOD m=SYMBOL
+ LINE l=NUMBER
+ BIND e=event
+ IF c=condition
+ DO a=action
+ ENDRULE -> ^(RULE $n $cl $m $l $e $c $a)
+ ;
eca_rule : eca EOF -> ^(eca)
;
@@ -63,14 +75,17 @@
// the type checking after parsing n.b. we always have at least one condition as an empty (i.e.
// vacuously true) condition is defined by an empty input string.
-condition : expr
+condition : TRUE -> ^(TRUE)
+ | FALSE -> ^(FALSE)
+ | expr
;
// actions area defined as a sequence of expressions.it not type-constrained by the grammar -- it's
// easier to do the type checking after parsing n.b. we always have at least one action as
// an empty (i.e. do nothing) action is defined by an empty action string
-action : action_expr_list
+action : NOTHING -> ^(NOTHING)
+ | action_expr_list
;
action_expr_list
Modified: labs/jbosstm/workspace/adinn/orchestration/dd/grammar/ECAToken.g
===================================================================
--- labs/jbosstm/workspace/adinn/orchestration/dd/grammar/ECAToken.g 2008-09-23 08:42:24 UTC (rev 23006)
+++ labs/jbosstm/workspace/adinn/orchestration/dd/grammar/ECAToken.g 2008-09-23 10:27:03 UTC (rev 23007)
@@ -1,4 +1,4 @@
-klexer grammar ECAToken;
+lexer grammar ECAToken;
@header {
package org.jboss.jbossts.orchestration.rule.grammar;
@@ -21,7 +21,6 @@
fragment
BAREINT : '0' | (POSDIGIT (DIGIT)*)
;
-
fragment
INTEGER : SIGN? BAREINT
;
@@ -53,6 +52,30 @@
DO : 'DO'
;
+RULE : 'RULE'
+ ;
+
+CLASS : 'CLASS'
+ ;
+
+METHOD : 'METHOD'
+ ;
+
+LINE : 'LINE'
+ ;
+
+ENDRULE : 'ENDRULE'
+ ;
+
+NOTHING : 'NOTHING'
+ ;
+
+TRUE : 'TRUE' | 'true'
+ ;
+
+FALSE : 'FALSE'|'false'
+ ;
+
// various bracket pairs
LPAREN : '('
@@ -130,7 +153,7 @@
;
GEQ : '>='
- | 'GEQ'
+ | 'EQ'
| 'geq'
;
@@ -223,7 +246,7 @@
BARESYM : (LETTER | UNDERSCORE) (LETTER | DIGIT | UNDERSCORE)*
;
fragment
-QUOTSYM : QUOTE (PUNCT |LETTER | UNDERSCORE | DIGIT | DQUOTE )* QUOTE
+QUOTSYM : QUOTE (PUNCT |LETTER | UNDERSCORE | DIGIT | DQUOTE |SPACE)* QUOTE
;
// n.b. dot separated symbol can contain zero or more dot separators
Added: labs/jbosstm/workspace/adinn/orchestration/handler.txt
===================================================================
--- labs/jbosstm/workspace/adinn/orchestration/handler.txt (rev 0)
+++ labs/jbosstm/workspace/adinn/orchestration/handler.txt 2008-09-23 10:27:03 UTC (rev 23007)
@@ -0,0 +1,223 @@
+##############################################################################
+#
+# This script automates testing of a specific recovery scenario for the
+# JBossTS XTS implementation of the WS-AT 1.1 protocol using orchestration
+# rules. The scenario is as follows:
+#
+# AS boots
+# Client starts a WS-AT transaction
+# Client invokes web service 1
+# Web service 1 registers as participant P1
+# Client invokes web service 2
+# Web service 2 registers as participant P2
+# Client commits WS-AT transaction
+# Coordinator initiates commit of participant P1
+# ** Rule system intercepts commit and crahses JVM
+#
+# AS reboots
+# Recovery system starts after 2 minutes
+# Recovery system recreates PREPARED WS-AT transaction coordinator
+# Recovery system recreates participant stub for P1
+# ** Rule system adds countdown(2) for P1
+# Recovery system recreates participant stub for P2
+# ** Rule system adds countdown for P2
+# Recovery system calls replay of PREPARED transaction
+# ** Rule system traces PREPARED replay invocation
+# Coordinator sends commit to P1
+# ** Rule system decrements P1's countdown to 1
+#
+# P1 replies with committed
+# ** Rule system intercepts committed message handler and aborts thread
+#
+# Coordinator sends commit to P2
+# ** Rule system decrements P2's countdown to 1
+# (last 2 steps repeated while countdown is active)
+#
+# P2 replies with committed
+# ** Rule system intercepts committed message handler and aborts thread
+# (last 2 steps repeated while countdown is active)
+#
+# Coordinator times out commit and writes heuristic transaction to log
+# Recovery system sleeps
+
+# Recovery system restarts after 2 minutes
+# Recovery system recreates HEURISTIC WS-AT transaction coordinator
+# Recovery system detects existing participant stub for P1
+# Recovery system detects existing participant stub for P2
+#
+# Coordinator sends commit to P1
+# ** Rule system decrements P1's countdown to 0 and removes countdown
+# P1 replies with committed
+# Coordinator sends commit to P2
+# ** Rule system decrements P2's countdown to 0 and removes countdown
+# P2 replies with committed
+# Coordinator clears heuristic log record and copletes commit
+# ** Rule system detects completed commit and kills JVM
+#
+# The number of participants must be at least 2 but can actually be
+# more. One way of exercising the test is to start the AS and run the
+# XTS demo. It should crash at the point of commit. At reboot the
+# rest of the test shoudl run automatically and the server should be
+# killed after a the heuristic transaction is successfuly killed. The
+# console (or server) log should contain messages indicating replays of
+# the prepared and then the heuristic transactions and then a message
+# indicating that the heuristic transacton has committed.
+
+#######################################################################
+# This rule is triggered when a participant stub (CoordinatorEngine) is
+# created from details located in the log record. It adds a countdown
+# which is tripped each time a commit is tried on the participant.
+# While the countdown is active committed messages will be blocked.
+# Note that it calls isRecovered() to detect that the stub has been
+# recreated from the log.
+# The line number is the line immediately following the invocation of
+# the super class constructor. Placing the trigger after the super
+# constructor call is vital for constructors since the rule cannot call
+# methods on the instance until after it has been initialized. In theory
+# it should be possible to set line = -1 and have the rule system compile
+# in the trigger call at the correct place. However, it is not smart enough
+# to do this just yet
+
+RULE add coordinator engine countdown
+CLASS com.arjuna.wst11.messaging.engines.CoordinatorEngine
+METHOD <init>(String, boolean, W3CEndpointReference, boolean, State)
+LINE 96
+BIND engine:CoordinatorEngine = $0,
+ recovered:boolean = engine.isRecovered(),
+ identifier:String = engine.getId()
+IF recovered
+DO debug("adding countdown for " + identifier),
+ addCountDown(identifier, 1)
+ENDRULE
+
+#######################################################################
+# This rule is triggered when a non-recovered participant stub
+# (CoordinatorEngine) is sent a commit message i.e. immediately
+# after a successful prepare. It exits the JVM, simulating a crash.
+# The line number is the first executable line in the method (it
+# could be specified as -1)
+
+RULE kill JVM
+CLASS com.arjuna.wst11.messaging.engines.CoordinatorEngine
+METHOD commit
+LINE 316
+BIND engine:CoordinatorEngine = $0,
+ recovered:boolean = engine.isRecovered(),
+ identifier:String = engine.getId()
+IF (NOT recovered)
+ AND
+ debug("commit on non-recovered engine " + identifier)
+DO debug("!!!killing JVM!!!"),
+ killJVM()
+ENDRULE
+
+#######################################################################
+# This rule is triggered when a recovered participant stub
+# (CoordinatorEngine) is sent a commit message i.e. immediately
+# after a successful prepare. It decrements the countdown. First
+# time round this takes it from 1 to 0 but leaves it in place. Second
+# time round it removes it allowing committed messages to flow.
+# The line number is the first executable line in the method (it
+# could be specified as -1)
+
+RULE countdown at commit
+CLASS com.arjuna.wst11.messaging.engines.CoordinatorEngine
+METHOD commit
+LINE 316
+BIND engine:CoordinatorEngine = $0,
+ recovered:boolean = engine.isRecovered(),
+ identifier:String = engine.getId()
+IF recovered
+ AND
+ debug("commit on recovered engine " + identifier)
+ AND
+ debug("counting down")
+ AND
+ countDown(identifier)
+DO debug("countdown completed for " + identifier)
+ENDRULE
+
+#######################################################################
+# This rule is triggered when a recovered participant stub
+# (CoordinatorEngine) is sent a committed message i.e. in the handler
+# thread which responds to a COMMITTED message from a participant.
+# If it detects a countdown registered using the participant id it
+# throws a runtime exception causing the thread to abort and stopping
+# delivery of the COMMITTED message. The line number is -1 so the
+# rule code gets run as soon as the method is entered.
+
+RULE kill committed thread
+CLASS com.arjuna.wst11.messaging.engines.CoordinatorEngine
+METHOD committed(Notification, AddressingProperties, ArjunaContext)
+LINE -1
+BIND engine:CoordinatorEngine = $0,
+ recovered:boolean = engine.isRecovered(),
+ identifier:String = engine.getId()
+IF recovered
+ AND
+ debug("committed on recovered engine " + identifier)
+ AND
+ getCountDown(identifier)
+DO debug("!!!killing committed thread for " + identifier + "!!!"),
+ killThread()
+ENDRULE
+
+#######################################################################
+# This rule is triggered when the recovery system finds the PREPARED
+# transaction in the log and reruns the phase 2 commit operation.
+# It prints a message which can be used to verify that the test has
+# worked correctly. The line number is the one where the call to
+# phase2Commit is called but actually the test would also work with
+# line = -1 since the condition selects the correct case.
+
+RULE trace prepared replay
+CLASS org.jboss.jbossts.xts.recovery.RecoverACCoordinator
+METHOD replayPhase2
+LINE 76
+BIND coordinator = $0,
+ uid : Uid = coordinator.identifier(),
+ status : int = coordinator.status(),
+IF (status == com.arjuna.ats.arjuna.coordinator.ActionStatus.PREPARED)
+ OR
+ (status == com.arjuna.ats.arjuna.coordinator.ActionStatus.COMMITTING)
+DO debug("replaying commit for prepared transaction " + uid)
+ENDRULE
+
+#######################################################################
+# This rule is triggered when the recovery system finds the COMMITTED
+# transaction in the log and reruns the phase 2 commit operation.
+# It prints a message which can be used to verify that the test has
+# worked correctly. The line number is the one where the call to
+# phase2Commit is called but actually the test would also work with
+# line = -1 since the condition selects the correct case.
+
+RULE trace heuristic committed replay
+CLASS org.jboss.jbossts.xts.recovery.RecoverACCoordinator
+METHOD replayPhase2
+LINE 76
+BIND coordinator = $0,
+ uid : Uid = coordinator.identifier(),
+ status : int = coordinator.status()
+IF status == com.arjuna.ats.arjuna.coordinator.ActionStatus.COMMITTED
+DO debug("replaying commit for heuristic committed transaction " + uid)
+ENDRULE
+
+#######################################################################
+# This rule is triggered when the recovery system deletes the COMMITTED
+# transaction from the log. It prints a message which can be used to
+# verify that the test has worked correctly. It also kills the JVM to
+# halt the test. The line number is the one just following the delete
+# of the record from the TX object store, ensuring that the JVM is not
+# exited until the log has actually been cleaned up.
+
+RULE trace remove committed state
+CLASS com.arjuna.ats.arjuna.coordinator.BasicAction
+METHOD updateState
+LINE 3513
+BIND action : BasicAction = $0,
+ uid = action.get_uid()
+IF TRUE
+DO debug("removed committed transaction " + uid),
+ debug("!!!killing JVM!!!"),
+ killJVM()
+ENDRULE
Modified: labs/jbosstm/workspace/adinn/orchestration/src/TestJar.java
===================================================================
--- labs/jbosstm/workspace/adinn/orchestration/src/TestJar.java 2008-09-23 08:42:24 UTC (rev 23006)
+++ labs/jbosstm/workspace/adinn/orchestration/src/TestJar.java 2008-09-23 10:27:03 UTC (rev 23007)
@@ -118,7 +118,7 @@
String event = eventHandler.event();
String condition = eventHandler.condition();
String action = eventHandler.action();
- Rule rule = Rule.create(ruleName, event, condition, action, loader);
+ Rule rule = Rule.create(ruleName, targetClassName, targetMethodName, targetLine, event, condition, action, loader);
System.err.println("TestJar: parsed rule " + ruleName);
System.err.println(rule);
rule.setTypeInfo(targetClassName, access, candidateName, candidateDesc);
@@ -148,7 +148,7 @@
String event = eventHandler.event();
String condition = eventHandler.condition();
String action = eventHandler.action();
- Rule rule = Rule.create(ruleName, event, condition, action, loader);
+ Rule rule = Rule.create(ruleName, targetClassName, targetMethodName, targetLine, event, condition, action, loader);
System.err.println("TestJar: parsed rule " + ruleName);
System.err.println(rule);
rule.setTypeInfo(targetClassName, access, candidateName, candidateDesc);
Modified: labs/jbosstm/workspace/adinn/orchestration/src/TestRule.java
===================================================================
--- labs/jbosstm/workspace/adinn/orchestration/src/TestRule.java 2008-09-23 08:42:24 UTC (rev 23006)
+++ labs/jbosstm/workspace/adinn/orchestration/src/TestRule.java 2008-09-23 10:27:03 UTC (rev 23007)
@@ -37,7 +37,7 @@
} else if ("-rule".equals(args[i])) {
System.out.println("Creating rule from " + args[++i]);
try {
- rule = Rule.create("TestRule" + i, args[i], loader);
+ rule = Rule.create("TestRule" + i, className, methodName, -1, args[i], loader);
System.out.print(rule);
if (methodName != null &&
className != null) {
@@ -51,7 +51,7 @@
} else if ("-event".equals(args[i])) {
System.out.println("Creating event from " + args[++i]);
try {
- rule = Rule.create("TestRule" + i, loader);
+ rule = Rule.create("TestRule" + i, className, methodName, -1, null, loader);
rule.setEvent(args[i]);
System.out.print(rule);
} catch (Throwable th) {
@@ -63,7 +63,7 @@
System.out.println("Creating condition from " + args[++i]);
try {
if (rule == null || rule.getCondition() != null) {
- rule = Rule.create("TestRule" + i, loader);
+ rule = Rule.create("TestRule" + i, className, methodName, -1, null, loader);
}
if (rule.getEvent() == null) {
rule.setEvent("");
@@ -79,7 +79,7 @@
System.out.println("Creating action from " + args[++i]);
try {
if (rule == null || rule.getAction() != null) {
- rule = Rule.create("TestRule" + i, loader);
+ rule = Rule.create("TestRule" + i, className, methodName, -1, null, loader);
}
if (rule.getEvent() == null) {
rule.setEvent("");
@@ -108,7 +108,7 @@
bytes = new byte[fis.available()];
fis.read(bytes);
text = new String(bytes);
- rule = Rule.create("TestRule" + i, text, loader);
+ rule = Rule.create("TestRule" + i, className, methodName, -1, text, loader);
System.out.print(rule);
if (methodName != null &&
className != null) {
Copied: labs/jbosstm/workspace/adinn/orchestration/src/TestScript.java (from rev 22809, labs/jbosstm/workspace/adinn/orchestration/src/TestJar.java)
===================================================================
--- labs/jbosstm/workspace/adinn/orchestration/src/TestScript.java (rev 0)
+++ labs/jbosstm/workspace/adinn/orchestration/src/TestScript.java 2008-09-23 10:27:03 UTC (rev 23007)
@@ -0,0 +1,255 @@
+import org.jboss.jbossts.orchestration.annotation.EventHandlerClass;
+import org.jboss.jbossts.orchestration.annotation.EventHandler;
+import org.jboss.jbossts.orchestration.rule.type.TypeHelper;
+import org.jboss.jbossts.orchestration.rule.type.Type;
+import org.jboss.jbossts.orchestration.rule.Rule;
+import org.jboss.jbossts.orchestration.rule.exception.ParseException;
+import org.jboss.jbossts.orchestration.rule.exception.TypeException;
+import org.jboss.jbossts.orchestration.rule.exception.CompileException;
+import org.objectweb.asm.Opcodes;
+
+import java.util.jar.JarFile;
+import java.util.jar.JarEntry;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.ArrayList;
+import java.io.File;
+import java.io.IOException;
+import java.io.FileInputStream;
+import java.net.URLClassLoader;
+import java.net.URL;
+import java.net.MalformedURLException;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.Constructor;
+
+public class TestScript
+{
+ public static void main(String[] args)
+ {
+ TestScript testScript = new TestScript();
+ testScript.testScript(args);
+ }
+
+ public void testScript(String[] scriptFiles)
+ {
+ for (String script : scriptFiles) {
+ try {
+ FileInputStream fis = new FileInputStream(new File(script));
+ System.out.println("checking classes in " + script);
+ List<String> rules = processRules(fis);
+ checkRules(rules);
+ } catch (IOException ioe) {
+ System.err.println("TestScript: unable to open rule script file : " + script);
+ }
+ }
+ }
+
+
+
+ private List<String> processRules(FileInputStream stream)
+ throws IOException
+ {
+ List<String> rules = new ArrayList<String>();
+
+ byte[] bytes = new byte[stream.available()];
+ stream.read(bytes);
+ String text = new String(bytes);
+ int length = text.length();
+ while (length > 0) {
+ int end = text.indexOf("ENDRULE");
+ if (end >= 0) {
+ end += "ENDRULE".length();
+ if (end < length && text.charAt(end) == '\n') {
+ end++;
+ }
+ rules.add(text.substring(0, end));
+ text = text.substring(end).trim();
+ } else {
+ rules.add(text);
+ text = "";
+ }
+ length = text.length();
+ }
+
+ return rules;
+ }
+
+ private void checkRules(List<String> ruleScripts)
+ {
+ ClassLoader loader = getClass().getClassLoader();
+
+ for (String script : ruleScripts) {
+ try {
+ String[] lines = script.split("\n");
+ String ruleName;
+ String targetClassName;
+ String targetMethodName;
+ int targetLine;
+ String text = "";
+ String sepr = "";
+ int idx = 0;
+ int len = lines.length;
+
+ while (lines[idx].trim().equals("") || lines[idx].trim().startsWith("#")) {
+ idx++;
+ }
+ if (lines[idx].startsWith("RULE ")) {
+ ruleName = lines[idx].substring(5);
+ idx++;
+ } else {
+ throw new ParseException("Rule should start with RULE : " + lines[idx]);
+ }
+ while (lines[idx].trim().equals("") || lines[idx].trim().startsWith("#")) {
+ idx++;
+ }
+ if (lines[idx].startsWith("CLASS ")) {
+ targetClassName = lines[idx].substring(6);
+ idx++;
+ } else {
+ throw new ParseException("CLASS should follow RULE : " + lines[idx]) ;
+ }
+ while (lines[idx].trim().equals("") || lines[idx].trim().startsWith("#")) {
+ idx++;
+ }
+ if (lines[idx].startsWith("METHOD ")) {
+ targetMethodName = lines[idx].substring(7);
+ idx++;
+ } else {
+ throw new ParseException("METHOD should follow CLASS : " + lines[idx]) ;
+ }
+ while (lines[idx].trim().equals("") || lines[idx].trim().startsWith("#")) {
+ idx++;
+ }
+ if (lines[idx].startsWith("LINE ")) {
+ String targetLineString = lines[idx].substring(5);
+ targetLine = Integer.valueOf(targetLineString);
+ idx++;
+ } else {
+ throw new ParseException("LINE should follow METHOD : " + lines[idx]) ;
+ }
+ for (;idx < len; idx++) {
+ if (lines[idx].trim().startsWith("#")) {
+ lines[idx] = "";
+ }
+ if (lines[idx].trim().equals("ENDRULE")) {
+ break;
+ }
+ text += sepr + lines[idx];
+ sepr = "\n";
+ }
+ Rule rule = Rule.create(ruleName, targetClassName, targetMethodName, targetLine, text, loader);
+ System.err.println("TestScript: parsed rule " + rule.getName());
+ System.err.println(rule);
+
+ String targetName = TypeHelper.parseMethodName(targetMethodName);
+ String targetDesc = TypeHelper.parseMethodDescriptor(targetMethodName);
+ boolean found = false;
+ boolean multiple = false;
+ try {
+ Class targetClass = loader.loadClass(targetClassName);
+ if (!targetName.equals("<init>")) {
+ Method[] candidates = targetClass.getDeclaredMethods();
+ for (Method candidate : candidates) {
+ String candidateName = candidate.getName();
+ String candidateDesc = makeDescriptor(candidate);
+ if (targetName.equals(candidateName)) {
+ if (targetDesc.equals("") || TypeHelper.equalDescriptors(targetDesc, candidateDesc)) {
+ System.err.println("TestJar: checking rule " + ruleName);
+ if (found) {
+ multiple = true;
+ break;
+ }
+ found = true;
+ int access = 0;
+ if ((candidate.getModifiers() & Modifier.STATIC) != 0) {
+ access = Opcodes.ACC_STATIC;
+ }
+ rule.setTypeInfo(targetClassName, access, candidateName, candidateDesc);
+ rule.typeCheck();
+ System.err.println("TestJar: type checked rule " + ruleName);
+ }
+ }
+ }
+ } else {
+ Constructor[] constructors = targetClass.getConstructors();
+ for (Constructor constructor : constructors) {
+ String candidateName = constructor.getName();
+ String candidateDesc = makeDescriptor(constructor);
+ if (targetName.equals("<init>")) {
+ if (targetDesc.equals("") || TypeHelper.equalDescriptors(targetDesc, candidateDesc)) {
+ System.err.println("TestJar: checking rule " + ruleName);
+ if (found) {
+ multiple = true;
+ break;
+ }
+ found = true;
+ int access = 0;
+ if ((constructor.getModifiers() & Modifier.STATIC) != 0) {
+ access = Opcodes.ACC_STATIC;
+ }
+ rule.setTypeInfo(targetClassName, access, candidateName, candidateDesc);
+ rule.typeCheck();
+ System.err.println("TestJar: type checked rule " + ruleName);
+ }
+ }
+ }
+ }
+ } catch(ClassNotFoundException cfe) {
+ System.err.println("TestScript: unable to load class " + targetClassName);
+ }
+ if (!found) {
+ System.err.println("TestJar: no matching method for rule " + ruleName);
+ } else if (multiple) {
+ System.err.println("TestJar: multiple matching methods for rule " + ruleName);
+ }
+ } catch (ParseException e) {
+ System.err.println("TestScript: parse exception for rule " + script + " : " + e);
+ e.printStackTrace(System.err);
+ } catch (TypeException e) {
+ System.err.println("TestScript: type exception for rule " + script + " : " + e);
+ e.printStackTrace(System.err);
+ } catch (CompileException e) {
+ System.err.println("TestScript: compile exception for rule " + " : " + script + e);
+ e.printStackTrace(System.err);
+ }
+ }
+ }
+
+ static String makeDescriptor(Method method)
+ {
+ Class<?> paramTypes[] = method.getParameterTypes();
+ Class<?> retType = method.getReturnType();
+ String desc = "(";
+
+ for (Class<?> paramType : paramTypes) {
+ String name = paramType.getCanonicalName();
+ desc += TypeHelper.externalizeType(name);
+ }
+ desc += ")";
+ desc += TypeHelper.externalizeType(retType.getCanonicalName());
+
+ return desc;
+ }
+
+ static String makeDescriptor(Constructor constructor)
+ {
+ Class<?> paramTypes[] = constructor.getParameterTypes();
+ String desc = "(";
+
+ for (Class<?> paramType : paramTypes) {
+ String name = paramType.getCanonicalName();
+ desc += TypeHelper.externalizeType(name);
+ }
+ desc += ")";
+
+ return desc;
+ }
+
+ /**
+ * suffix found on end of .class files (doh :-)
+ */
+
+ private static final String CLASS_FILE_SUFFIX = ".class";
+}
\ No newline at end of file
Modified: labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/agent/Main.java
===================================================================
--- labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/agent/Main.java 2008-09-23 08:42:24 UTC (rev 23006)
+++ labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/agent/Main.java 2008-09-23 10:27:03 UTC (rev 23007)
@@ -11,6 +11,7 @@
import java.util.Enumeration;
import java.io.File;
import java.io.IOException;
+import java.io.FileInputStream;
import java.net.URLClassLoader;
import java.net.URL;
import java.net.MalformedURLException;
@@ -19,7 +20,9 @@
* agent class supplied at JVM startup to install orchestration package bytecode transformer
*/
public class Main {
- public static void premain(String args, Instrumentation inst) {
+ public static void premain(String args, Instrumentation inst)
+ throws Exception
+ {
if (args != null) {
// args are supplied eparated by ',' characters
String[] argsArray = args.split(",");
@@ -27,12 +30,12 @@
for (String arg : argsArray) {
if (arg.startsWith(BOOT_PREFIX)) {
bootJarPaths.add(arg.substring(BOOT_PREFIX.length(), arg.length()));
- } else if (arg.startsWith(RULE_PREFIX)) {
- ruleJarPaths.add(arg.substring(RULE_PREFIX.length(), arg.length()));
+ } else if (arg.startsWith(SCRIPT_PREFIX)) {
+ scriptPaths.add(arg.substring(SCRIPT_PREFIX.length(), arg.length()));
} else {
System.err.println("org.jboss.jbossts.orchestration.agent.Main:\n" +
" illegal agent argument : " + arg + "\n" +
- " valid arguments are boot:<path-to-jar> or rule:<path-to-jar>");
+ " valid arguments are boot:<path-to-jar> or script:<path-to-scriptr>");
}
}
}
@@ -46,84 +49,55 @@
// inst.appendToBootstrapClassLoaderSearch(jarfile);
} catch (IOException ioe) {
System.err.println("org.jboss.jbossts.orchestration.agent.Main: unable to open boot jar file : " + bootJarPath);
+ throw ioe;
}
}
- // look up rules in any rule jars
+ // look up rules in any script files
- for (String ruleJarPath : ruleJarPaths) {
+ for (String scriptPath : scriptPaths) {
try {
- JarFile jarFile = new JarFile(new File(ruleJarPath));
- processRules(jarFile);
+ System.out.println("processing script file " + scriptPath);
+
+ FileInputStream fis = new FileInputStream(scriptPath);
+ byte[] bytes = new byte[fis.available()];
+ fis.read(bytes);
+ String ruleScript = new String(bytes);
+ scripts.add(ruleScript);
} catch (IOException ioe) {
- System.err.println("org.jboss.jbossts.orchestration.agent.Main: unable to open rule jar file : " + ruleJarPath);
+ System.err.println("org.jboss.jbossts.orchestration.agent.Main: unable to read rule script file : " + scriptPath);
+ throw ioe;
}
}
// install an instance of Transformer to instrument the bytecode
- inst.addTransformer(new Transformer(inst, ruleClasses));
+ inst.addTransformer(new Transformer(inst, scriptPaths, scripts));
}
- private static void processRules(JarFile jarFile)
- {
- try {
- URLClassLoader classLoader = new URLClassLoader(new URL[] { new URL("file:" + jarFile.getName()) });
- Enumeration<JarEntry> jarEntries = jarFile.entries();
-
- while (jarEntries.hasMoreElements()) {
- JarEntry jarEntry = jarEntries.nextElement();
- String entryName = jarEntry.getName();
-
- if (entryName.endsWith(CLASS_FILE_SUFFIX)) {
- // try to load the rule class
- int classNameLength = entryName.length() - CLASS_FILE_SUFFIX.length();
- String className = entryName.substring(0, classNameLength).replaceAll("/", ".");
- try {
- Class clazz = classLoader.loadClass(className);
- Annotation a = clazz.getAnnotation(EventHandlerClass.class);
- if (a != null) {
- ruleClasses.add(clazz);
- }
- } catch (ClassNotFoundException e) {
- System.err.println("org.jboss.jbossts.orchestration.agent.Main: unable to load class " + className + " from : " + jarFile.getName());
- }
- }
- }
- } catch (MalformedURLException mue) {
- System.err.println("org.jboss.jbossts.orchestration.agent.Main: unable to load classes from : " + jarFile.getName());
- }
- }
-
/**
* prefix used to specify boot jar argument for agent
*/
private static final String BOOT_PREFIX = "boot:";
/**
- * prefix used to specify rulejar argument for agent
+ * prefix used to specify script argument for agent
*/
- private static final String RULE_PREFIX = "rule:";
+ private static final String SCRIPT_PREFIX = "script:";
/**
- * suffix found on end of .class files (doh :-)
- */
-
- private static final String CLASS_FILE_SUFFIX = ".class";
-
- /**
* list of paths to extra bootstrap jars supplied on command line
*/
private static List<String> bootJarPaths = new ArrayList<String>();
/**
- * list of paths to rule jars supplied on command line
+ * list of paths to script files supplied on command line
*/
- private static List<String> ruleJarPaths = new ArrayList<String>();
+ private static List<String> scriptPaths = new ArrayList<String>();
/**
- * list of classes annotated with methods annotated with event handler annotations
+ * list of scripts read from script files
*/
- private static List<Class> ruleClasses = new ArrayList<Class>();
+ private static List<String> scripts = new ArrayList<String>();
}
Modified: labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/agent/Transformer.java
===================================================================
--- labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/agent/Transformer.java 2008-09-23 08:42:24 UTC (rev 23006)
+++ labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/agent/Transformer.java 2008-09-23 10:27:03 UTC (rev 23007)
@@ -19,6 +19,7 @@
import java.util.List;
import java.util.HashMap;
import java.util.ArrayList;
+import java.util.Iterator;
import java.io.PrintWriter;
import java.io.FileOutputStream;
import java.io.IOException;
@@ -33,37 +34,89 @@
*
* @param inst the instrumentation object used to interface to the JVM
*/
- public Transformer(Instrumentation inst, List<Class> ruleClasses)
+ public Transformer(Instrumentation inst, List<String> scriptPaths, List<String> scriptTexts)
+ throws Exception
{
this.inst = inst;
- this.ruleClasses = ruleClasses;
- targetToHandlerClassMap = new HashMap<String, List<Annotation>>();
- targetToHandlerMethodMap = new HashMap<String, List<Method>>();
+ targetToScriptMap = new HashMap<String, List<Script>>();
- // insert all event handling methods into the map indexed by the associated target class
-
- for (Class ruleClass : ruleClasses) {
- Annotation classAnnotation = ruleClass.getAnnotation(EventHandlerClass.class);
- for (Method method : ruleClass.getDeclaredMethods()) {
- EventHandler eventHandler = method.getAnnotation(EventHandler.class);
- if (eventHandler != null) {
- String target = eventHandler.targetClass();
- if (isTransformable(target) && !isOrchestrationClass(target)) {
- List<Annotation> clazzes = targetToHandlerClassMap.get(target);
- if (clazzes == null) {
- clazzes = new ArrayList<Annotation>();
+ Iterator<String> iter = scriptTexts.iterator();
+ int scriptIdx = 0;
+ while (iter.hasNext()) {
+ String scriptText = iter.next();
+ if (scriptText != null) {
+ // split rules into separate lines
+ String[] lines = scriptText.split("\n");
+ List<String> rules = new ArrayList<String>();
+ String nextRule = "";
+ String sepr = "";
+ String name = null;
+ String targetClass = null;
+ String targetMethod = null;
+ int targetLine = -1;
+ int lineNumber = 0;
+ int maxLines = lines.length;
+ boolean inRule = false;
+ for (String line : lines) {
+ lineNumber++;
+ if (line.trim().startsWith("#")) {
+ if (inRule) {
+ // add a blank line in place of the comment so the line numbers
+ // are reported consistently during parsing
+ nextRule += sepr;
+ sepr = "\n";
+ } // else { // just drop comment line }
+ } else if (line.startsWith("RULE ")) {
+ inRule = true;
+ name = line.substring(5).trim();
+ } else if (!inRule) {
+ if (!line.trim().equals("")) {
+ throw new Exception("org.jboss.jbossts.orchestration.agent.Transformer: invalid text outside of RULE/ENDRULE " + "at line " + lineNumber + " in script " + scriptPaths.get(scriptIdx));
}
- if (!clazzes.contains(classAnnotation)) {
- clazzes.add(classAnnotation);
+ } else if (line.startsWith("CLASS ")) {
+ targetClass = line.substring(6).trim();
+ } else if (line.startsWith("METHOD ")) {
+ targetMethod = line.substring(7).trim();
+ } else if (line.startsWith("LINE ")) {
+ String lineSpec = line.substring(5).trim();
+ try {
+ targetLine = Integer.valueOf(lineSpec);
+ } catch (NumberFormatException e) {
+ throw new Exception("org.jboss.jbossts.orchestration.agent.Transformer: invalid LINE specification " + lineSpec + "for RULE " + name + " in script " + scriptPaths.get(scriptIdx));
}
- List<Method> methods = targetToHandlerMethodMap.get(target);
- if (methods == null) {
- methods = new ArrayList<Method>();
- targetToHandlerMethodMap.put(target, methods);
+ } else if (line.startsWith("ENDRULE")) {
+ if (name == null) {
+ throw new Exception("org.jboss.jbossts.orchestration.agent.Transformer: no matching RULE for ENDRULE at line " + lineNumber + " in script " + scriptPaths.get(scriptIdx));
+ } else if (targetClass == null) {
+ throw new Exception("org.jboss.jbossts.orchestration.agent.Transformer: no CLASS for RULE " + name + " in script " + scriptPaths.get(scriptIdx));
+ } else if (targetMethod == null) {
+ throw new Exception("org.jboss.jbossts.orchestration.agent.Transformer: no METHOD for RULE " + name + " in script " + scriptPaths.get(scriptIdx));
+ } else {
+ List<Script> scripts = targetToScriptMap.get(targetClass);
+ if (scripts == null) {
+ scripts = new ArrayList<Script>();
+ targetToScriptMap.put(targetClass, scripts);
+ }
+ Script script = new Script(name, targetClass, targetMethod, targetLine, nextRule);
+ scripts.add(script);
+ System.out.println("RULE " + script.getName());
+ System.out.println("CLASS " + script.getTargetClass());
+ System.out.println("METHOD " + script.getTargetMethod());
+ System.out.println("LINE " + script.getTargetLine());
+ System.out.println(script.getRuleText());
+ System.out.println("ENDRULE");
}
- methods.add(method);
+ name = null;
+ targetClass = null;
+ targetMethod = null;
+ nextRule = "";
+ sepr = "";
+ inRule = false;
+ } else if (lineNumber == maxLines && !nextRule.trim().equals("")) {
+ throw new Exception("org.jboss.jbossts.orchestration.agent.Transformer: no matching ENDRULE for RULE " + name + " in script " + scriptPaths.get(scriptIdx));
} else {
- System.err.println("org.jboss.jbossts.orchestration.agent.Transformer: requested to transform invalid class " + target);
+ nextRule += sepr + line;
+ sepr = "\n";
}
}
}
@@ -142,42 +195,45 @@
return null;
}
- // ok, we need to check whether there are any event handlers associated with this class and if so
+ // ok, we need to check whether there are any scripts associated with this class and if so
// we will consider transforming the byte code
- List<Method> handlerMethods = targetToHandlerMethodMap.get(internalClassName);
+ List<Script> scripts = targetToScriptMap.get(internalClassName);
- if (handlerMethods != null) {
- for (Method handlerMethod : handlerMethods) {
+ if (scripts != null) {
+ for (Script script : scripts) {
try {
- newBuffer = transform(handlerMethod.getAnnotation(EventHandler.class), loader, internalClassName, classBeingRedefined, newBuffer);
+ newBuffer = transform(script, loader, internalClassName, classBeingRedefined, newBuffer);
} catch (Throwable th) {
- System.err.println("transform : caught throwable " + th);
+ System.err.println("Transformer.transform : caught throwable " + th);
th.printStackTrace(System.err);
}
}
}
- // if the class is not in the defautl package then we also need to look for handlers
+ // if the class is not in the default package then we also need to look for scripts
// which specify the class without the package qualification
int dotIdx = internalClassName.lastIndexOf('.');
if (dotIdx >= 0) {
- handlerMethods = targetToHandlerMethodMap.get(internalClassName.substring(dotIdx + 1));
- if (handlerMethods != null) {
- for (Method handlerMethod : handlerMethods) {
+ scripts = targetToScriptMap.get(internalClassName.substring(dotIdx + 1));
+
+ if (scripts != null) {
+ for (Script script : scripts) {
try {
- newBuffer = transform(handlerMethod.getAnnotation(EventHandler.class), loader, internalClassName, classBeingRedefined, newBuffer);
+ newBuffer = transform(script, loader, internalClassName, classBeingRedefined, newBuffer);
} catch (Throwable th) {
- System.err.println("transform : caught throwable " + th);
+ System.err.println("Transformer.transform : caught throwable " + th);
th.printStackTrace(System.err);
}
}
}
+
}
if (newBuffer != classfileBuffer) {
+ // switch on to dump transformed bytecode for checking
if (false) {
String name = (dotIdx < 0 ? internalClassName : internalClassName.substring(dotIdx + 1));
name += ".class";
@@ -197,22 +253,20 @@
}
}
- private byte[] transform(EventHandler handler, ClassLoader loader, String className, Class classBeingRedefined, byte[] targetClassBytes)
+
+ private byte[] transform(Script script, ClassLoader loader, String className, Class classBeingRedefined, byte[] targetClassBytes)
{
- final String handlerClass = handler.targetClass();
- final String handlerMethod = handler.targetMethod();
- final int handlerLine = handler.targetLine();
+ final String handlerClass = script.getTargetClass();
+ final String handlerMethod = script.getTargetMethod();
+ final int handlerLine = script.getTargetLine();
System.out.println("org.jboss.jbossts.orchestration.agent.Transformer: Inserting trigger event");
System.out.println(" class " + handlerClass);
System.out.println(" method " + handlerMethod);
System.out.println(" line " + handlerLine);
final Rule rule;
- String ruleName = handlerClass + "::" + handlerMethod;
- if (handlerLine >= 0) {
- ruleName += "@" + handlerLine;
- }
+ String ruleName = script.getName();
try {
- rule = Rule.create(ruleName, handler.event(), handler.condition(), handler.action(), loader);
+ rule = Rule.create(ruleName, handlerClass, handlerMethod, handlerLine, script.getRuleText(), loader);
} catch (ParseException pe) {
System.out.println("Transformer : error parsing rule : " + pe);
return targetClassBytes;
@@ -290,24 +344,51 @@
private final Instrumentation inst;
/**
- * the set of rule classes supplied to the agent program
+ * a mapping from class names which appear in rule targets to a script object holding the
+ * rule details
*/
- private final List<Class> ruleClasses;
+ private final HashMap<String, List<Script>> targetToScriptMap;
+
/**
- * a mapping from class names which appear in rule targets to the associated event handling methods
+ * information about a single rule derived from a rule script
*/
+
+ private static class Script
+ {
+ private String name;
+ private String targetClass;
+ private String targetMethod;
+ private int targetLine;
+ private String ruleText;
- private final HashMap<String, List<Method>> targetToHandlerMethodMap;
+ Script (String name, String targetClass, String targetMethod, int targetLine, String ruleText)
+ {
+ this.name = name;
+ this.targetClass = targetClass;
+ this.targetMethod = targetMethod;
+ this.targetLine = targetLine;
+ this.ruleText = ruleText;
+ }
- /**
- * a mapping from class names which appear in rule targets to the associated event handling classes
- */
+ public String getName() {
+ return name;
+ }
- private final HashMap<String, List<Annotation>> targetToHandlerClassMap;
-
- /**
- * external form of ECA rule class from which synthesised ECA handler classes are derived
- */
- private static final String ECA_RULE_CLASS_NAME = "org/jboss/jbossts/orchestration/rule/ECARule";
+ public String getTargetClass() {
+ return targetClass;
+ }
+
+ public String getTargetMethod() {
+ return targetMethod;
+ }
+
+ public int getTargetLine() {
+ return targetLine;
+ }
+
+ public String getRuleText() {
+ return ruleText;
+ }
+ }
}
Modified: labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/Action.java
===================================================================
--- labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/Action.java 2008-09-23 08:42:24 UTC (rev 23006)
+++ labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/Action.java 2008-09-23 10:27:03 UTC (rev 23007)
@@ -14,6 +14,7 @@
import org.jboss.jbossts.orchestration.rule.exception.ExecuteException;
import java.util.List;
+import java.util.ArrayList;
import java.io.StringWriter;
/**
@@ -49,7 +50,11 @@
protected Action(Rule rule, CommonTree actionTree) throws TypeException
{
super(rule);
- this.action = ExpressionHelper.createExpressionList(this.getBindings(), actionTree, Type.VOID);
+ if (actionTree.getToken().getType() == ECAGrammarParser.NOTHING) {
+ this.action = new ArrayList<Expression>();
+ } else {
+ this.action = ExpressionHelper.createExpressionList(this.getBindings(), actionTree, Type.VOID);
+ }
}
protected Action(Rule rule)
Modified: labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/Condition.java
===================================================================
--- labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/Condition.java 2008-09-23 08:42:24 UTC (rev 23006)
+++ labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/Condition.java 2008-09-23 10:27:03 UTC (rev 23007)
@@ -4,11 +4,14 @@
import org.antlr.runtime.ANTLRStringStream;
import org.antlr.runtime.CommonTokenStream;
import org.antlr.runtime.RecognitionException;
+import org.antlr.runtime.Token;
import org.jboss.jbossts.orchestration.rule.type.TypeGroup;
import org.jboss.jbossts.orchestration.rule.type.Type;
import org.jboss.jbossts.orchestration.rule.binding.Bindings;
import org.jboss.jbossts.orchestration.rule.expression.ExpressionHelper;
import org.jboss.jbossts.orchestration.rule.expression.Expression;
+import org.jboss.jbossts.orchestration.rule.expression.BooleanExpression;
+import org.jboss.jbossts.orchestration.rule.expression.BooleanLiteral;
import org.jboss.jbossts.orchestration.rule.grammar.ECATokenLexer;
import org.jboss.jbossts.orchestration.rule.grammar.ECAGrammarParser;
import org.jboss.jbossts.orchestration.rule.exception.ParseException;
@@ -50,9 +53,16 @@
throws TypeException
{
super(rule);
- this.condition = ExpressionHelper.createExpression(rule.getBindings(), conditionTree, Type.BOOLEAN);
+ Token token = conditionTree.getToken();
+ if (token.getType() == ECAGrammarParser.TRUE) {
+ this.condition = new BooleanLiteral(token, true);
+ } else if (token.getType() == ECAGrammarParser.FALSE) {
+ this.condition = new BooleanLiteral(token, false);
+ } else {
+ this.condition = ExpressionHelper.createExpression(rule.getBindings(), conditionTree, Type.BOOLEAN);
+ }
}
-
+
protected Condition(Rule rule)
{
super(rule);
Modified: labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/Rule.java
===================================================================
--- labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/Rule.java 2008-09-23 08:42:24 UTC (rev 23006)
+++ labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/Rule.java 2008-09-23 10:27:03 UTC (rev 23007)
@@ -18,6 +18,8 @@
import org.antlr.runtime.tree.CommonTree;
import org.objectweb.asm.Opcodes;
+import static org.jboss.jbossts.orchestration.rule.grammar.ECAGrammarParser.*;
+
import java.io.StringWriter;
import java.util.List;
import java.util.ArrayList;
@@ -30,28 +32,137 @@
*/
public class Rule
{
+ /**
+ * the name of this rule supplied in the rule script
+ */
+ private String name;
+ /**
+ * the name of the target class for this rule supplied in the rule script
+ */
+ private String targetClass;
+ /**
+ * the name of the triggering method on the target class for this rule supplied in the
+ * rule script
+ */
+ private String targetMethod;
+ /**
+ * the line number at which to insert the trigger call in the target method for this rule
+ * supplied in the rule script
+ */
+ private int targetLine;
+ /**
+ * the parsed event derived from the script for this rule
+ */
private Event event;
+ /**
+ * the parsed condition derived from the script for this rule
+ */
private Condition condition;
+ /**
+ * the parsed condition derived from the script for this rule
+ */
private Action action;
- Bindings bindings;
- private TypeGroup typeGroup;
- private String name;
- private boolean checked;
- private boolean checkFailed;
+ /**
+ * the set of bindings derived from the event supplemented, post type checking, with bindings
+ * derived from the trigger method. we may eventually also be able to install bindings for
+ * method local variables.
+ *
+ * Note that use of the name bindings is slightly misleading since this instance identifies the
+ * name and type of each of the available bound variables and, in the case of an event binding,
+ * the expression to be evaluated in order to initialise the variable. It does not identify
+ * any bound values for the variable. These are stored <em>per rule-firing</em> in a set
+ * attached to the Helper instance used to implement the execute method for the rule.
+ */
+ private Bindings bindings;
+ /**
+ * the fully qualified name of the class to which this rule has been attached by the code
+ * transformation package. note that this may not be the same as targetClass since the
+ * latter may not specify a package.
+ */
private String triggerClass;
+ /**
+ * the name of the trigger method in which a trigger call for this rule has been inserted by
+ * the code transformation package, not including the descriptor component. note that this
+ * may not be the same as the targetMethod since the latter may include an argument list.
+ */
private String triggerMethod;
+ /**
+ * the descriptor of the trigger method in which a trigger call for this rule has been inserted
+ * by the code transformation package. note that this will be in encoded format e.g. "(IZ)V"
+ * rather than declaration format e.g. "void (int, boolean)"
+ */
private String triggerDescriptor;
+ /**
+ * the access mode for the target method defined using flag bits defined in the asm Opcodes
+ * class.
+ */
private int triggerAccess;
+ /**
+ * the set of types employed by the rule, inlcuding types referenced by abbreviated name (without
+ * mentioning the package), array type sand/or their base types and standard builtin types.
+ */
+ private TypeGroup typeGroup;
+ /**
+ * flag set to true only after the rule has been type checked
+ */
+ private boolean checked;
+ /**
+ * flag set to true only after the rule has been type checked successfully
+ */
+ private boolean checkFailed;
- private Rule(String name, ClassLoader loader)
+ private Rule(String script, ClassLoader loader)
throws ParseException, TypeException, CompileException
{
- this.name = name;
+ CommonTree ruleTree;
+
typeGroup = new TypeGroup(loader);
bindings = new Bindings();
- event = null;
- condition = null;
- action = null;
+ try {
+ ECATokenLexer lexer = new ECATokenLexer(new ANTLRStringStream(script));
+ CommonTokenStream tokenStream = new CommonTokenStream(lexer);
+ ECAGrammarParser parser = new ECAGrammarParser(tokenStream);
+ ECAGrammarParser.eca_script_rule_return eca_script_rule = parser.eca_script_rule();
+ ruleTree = (CommonTree) eca_script_rule.getTree();
+ } catch (RecognitionException e) {
+ throw new ParseException("org.jboss.jbossts.orchestration.rule.Rule : error parsing rule " + script, e);
+ }
+ // format is ^(RULE name class method line event condition action)
+
+ CommonTree nameTree = (CommonTree)ruleTree.getChild(0);
+ CommonTree classTree = (CommonTree)ruleTree.getChild(1);
+ CommonTree methodTree = (CommonTree)ruleTree.getChild(2);
+ CommonTree lineTree = (CommonTree)ruleTree.getChild(3);
+ CommonTree eventTree = (CommonTree)ruleTree.getChild(4);
+ CommonTree conditionTree = (CommonTree)ruleTree.getChild(5);
+ CommonTree actionTree = (CommonTree)ruleTree.getChild(6);
+ if (nameTree.getToken().getType() != SYMBOL) {
+ throw new ParseException("org.jboss.jbossts.orchestration.rule.Rule : invalid rule name " + script);
+ } else {
+ name = nameTree.getToken().getText();
+ }
+ if (classTree.getToken().getType() != SYMBOL) {
+ throw new ParseException("org.jboss.jbossts.orchestration.rule.Rule : invalid class name " + script);
+ } else {
+ targetClass = classTree.getToken().getText();
+ }
+ if (methodTree.getToken().getType() != SYMBOL) {
+ throw new ParseException("org.jboss.jbossts.orchestration.rule.Rule : invalid method name " + script);
+ } else {
+ targetMethod = methodTree.getToken().getText();
+ }
+ if (lineTree.getToken().getType() != NUMBER) {
+ throw new ParseException("org.jboss.jbossts.orchestration.rule.Rule : invalid line number" + script);
+ } else {
+ try {
+ targetLine = Integer.valueOf(lineTree.getToken().getText());
+ } catch (NumberFormatException ne) {
+ throw new ParseException("org.jboss.jbossts.orchestration.rule.Rule : invalid format for line number" + script);
+ }
+ }
+ event = Event.create(this, eventTree);
+ condition = Condition.create(this, conditionTree);
+ action = Action.create(this, actionTree);
checked = false;
triggerClass = null;
triggerMethod = null;
@@ -59,7 +170,7 @@
triggerAccess = 0;
}
- private Rule(String name, String eventSpec, String conditionSpec, String actionSpec, ClassLoader loader)
+ private Rule(String name, String targetClass, String targetMethod, int targetLine, String eventSpec, String conditionSpec, String actionSpec, ClassLoader loader)
throws ParseException, TypeException, CompileException
{
this.name = name;
@@ -70,13 +181,16 @@
condition = Condition.create(this, conditionSpec);
action = Action.create(this, actionSpec);
checked = false;
+ this.targetClass = targetClass;
+ this.targetMethod = targetMethod;
+ this.targetLine = targetLine;
triggerClass = null;
triggerMethod = null;
triggerDescriptor = null;
triggerAccess = 0;
}
- private Rule(String name, String ruleSpec, ClassLoader loader)
+ private Rule(String name, String targetClass, String targetMethod, int targetLine, String ruleSpec, ClassLoader loader)
throws ParseException, TypeException, CompileException
{
CommonTree ruleTree;
@@ -84,22 +198,27 @@
this.name = name;
typeGroup = new TypeGroup(loader);
bindings = new Bindings();
- try {
- ECATokenLexer lexer = new ECATokenLexer(new ANTLRStringStream(ruleSpec));
- CommonTokenStream tokenStream = new CommonTokenStream(lexer);
- ECAGrammarParser parser = new ECAGrammarParser(tokenStream);
- ECAGrammarParser.eca_rule_return rule_parse = parser.eca_rule();
- ruleTree = (CommonTree) rule_parse.getTree();
- } catch (RecognitionException e) {
- throw new ParseException("org.jboss.jbossts.orchestration.rule.Rule : error parsing rule " + ruleSpec, e);
+ if (ruleSpec != null) {
+ try {
+ ECATokenLexer lexer = new ECATokenLexer(new ANTLRStringStream(ruleSpec));
+ CommonTokenStream tokenStream = new CommonTokenStream(lexer);
+ ECAGrammarParser parser = new ECAGrammarParser(tokenStream);
+ ECAGrammarParser.eca_rule_return rule_parse = parser.eca_rule();
+ ruleTree = (CommonTree) rule_parse.getTree();
+ } catch (RecognitionException e) {
+ throw new ParseException("org.jboss.jbossts.orchestration.rule.Rule : error parsing rule " + ruleSpec, e);
+ }
+ CommonTree eventTree = (CommonTree)ruleTree.getChild(0);
+ CommonTree conditionTree = (CommonTree)ruleTree.getChild(1);
+ CommonTree actionTree = (CommonTree)ruleTree.getChild(2);
+ event = Event.create(this, eventTree);
+ condition = Condition.create(this, conditionTree);
+ action = Action.create(this, actionTree);
}
- CommonTree eventTree = (CommonTree)ruleTree.getChild(0);
- CommonTree conditionTree = (CommonTree)ruleTree.getChild(1);
- CommonTree actionTree = (CommonTree)ruleTree.getChild(2);
- event = Event.create(this, eventTree);
- condition = Condition.create(this, conditionTree);
- action = Action.create(this, actionTree);
checked = false;
+ this.targetClass = targetClass;
+ this.targetMethod = targetMethod;
+ this.targetLine = targetLine;
triggerClass = null;
triggerMethod = null;
triggerDescriptor = null;
@@ -120,6 +239,18 @@
return name;
}
+ public String getTargetClass() {
+ return targetClass;
+ }
+
+ public String getTargetMethod() {
+ return targetMethod;
+ }
+
+ public int getTargetLine() {
+ return targetLine;
+ }
+
public Event getEvent()
{
return event;
@@ -133,22 +264,22 @@
return action;
}
- public static Rule create(String name, String eventSpec, String conditionSpec, String actionSpec, ClassLoader loader)
+ public static Rule create(String name, String targetClass, String targetMethod, int targetLine, String eventSpec, String conditionSpec, String actionSpec, ClassLoader loader)
throws ParseException, TypeException, CompileException
{
- return new Rule(name, eventSpec, conditionSpec, actionSpec, loader);
+ return new Rule(name, targetClass, targetMethod, targetLine, eventSpec, conditionSpec, actionSpec, loader);
}
- public static Rule create(String name, String ruleSpec, ClassLoader loader)
+ public static Rule create(String name, String targetClass, String targetMethod, int targetLine, String ruleSpec, ClassLoader loader)
throws ParseException, TypeException, CompileException
{
- return new Rule(name, ruleSpec, loader);
+ return new Rule(name, targetClass, targetMethod, targetLine, ruleSpec, loader);
}
- public static Rule create(String name, ClassLoader loader)
+ public static Rule create(String ruleScript, ClassLoader loader)
throws ParseException, TypeException, CompileException
{
- return new Rule(name, loader);
+ return new Rule(ruleScript, loader);
}
public void setEvent(String eventSpec) throws ParseException, TypeException
Copied: labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/expression/BooleanLiteral.java (from rev 22809, labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/expression/LogicalExpression.java)
===================================================================
--- labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/expression/BooleanLiteral.java (rev 0)
+++ labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/expression/BooleanLiteral.java 2008-09-23 10:27:03 UTC (rev 23007)
@@ -0,0 +1,59 @@
+package org.jboss.jbossts.orchestration.rule.expression;
+
+import org.jboss.jbossts.orchestration.rule.type.Type;
+import org.jboss.jbossts.orchestration.rule.type.TypeGroup;
+import org.jboss.jbossts.orchestration.rule.binding.Bindings;
+import org.jboss.jbossts.orchestration.rule.exception.TypeException;
+import org.jboss.jbossts.orchestration.rule.exception.ExecuteException;
+import org.jboss.jbossts.orchestration.rule.Rule;
+import org.antlr.runtime.Token;
+
+import java.io.StringWriter;
+
+/**
+ * A binary logical operator expression
+ */
+public class BooleanLiteral extends Expression
+{
+ private boolean value;
+
+ public BooleanLiteral(Token token, Boolean value)
+ {
+ super(Type.Z, token);
+ this.value = value;
+ }
+
+
+ /**
+ * verify that variables mentioned in this expression are actually available in the supplied
+ * bindings list and infer/validate the type of this expression or its subexpressions
+ * where possible
+ *
+ * @param bindings the set of bindings in place at the point of evaluation of this expression
+ * @return true if all variables in this expression are bound and no type mismatches have
+ * been detected during inference/validation.
+ */
+ public boolean bind(Bindings bindings) {
+ return false; //To change body of implemented methods use File | Settings | File Templates.
+ }
+
+ public Type typeCheck(Bindings bindings, TypeGroup typegroup, Type expected) throws TypeException {
+ type = Type.Z;
+ if (Type.dereference(expected).isDefined() && !expected.isAssignableFrom(type)) {
+ throw new TypeException("BooleanLiteral.typeCheck : invalid expected result type " + expected.getName() + getPos());
+ }
+ return type;
+ }
+
+ public Object interpret(Rule.BasicHelper helper) throws ExecuteException {
+ return value;
+ }
+
+ public void writeTo(StringWriter stringWriter) {
+ if (value) {
+ stringWriter.write("TRUE");
+ } else {
+ stringWriter.write("FALSE");
+ }
+ }
+}
\ No newline at end of file
Modified: labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/expression/ExpressionHelper.java
===================================================================
--- labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/expression/ExpressionHelper.java 2008-09-23 08:42:24 UTC (rev 23006)
+++ labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/expression/ExpressionHelper.java 2008-09-23 10:27:03 UTC (rev 23007)
@@ -53,6 +53,11 @@
// check for embedded dots
String text = token.getText();
+ int length = text.length();
+ // strip off any surrounding single quotes
+ if (length > 1 && text.charAt(0) == '\'' && text.charAt(length - 1) == '\'') {
+ text = text.substring(1, length - 1);
+ }
int dotIdx = text.lastIndexOf('.');
if (dotIdx < 0) {
// direct variable reference
Modified: labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/grammar/ECAGrammarParser.java
===================================================================
--- labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/grammar/ECAGrammarParser.java 2008-09-23 08:42:24 UTC (rev 23006)
+++ labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/grammar/ECAGrammarParser.java 2008-09-23 10:27:03 UTC (rev 23007)
@@ -1,4 +1,4 @@
-// $ANTLR 3.0.1 dd/grammar/ECAGrammar.g 2008-09-15 14:07:44
+// $ANTLR 3.0.1 dd/grammar/ECAGrammar.g 2008-09-22 16:26:20
package org.jboss.jbossts.orchestration.rule.grammar;
@@ -14,77 +14,85 @@
public class ECAGrammarParser extends Parser {
public static final String[] tokenNames = new String[] {
- "<invalid>", "<EOR>", "<DOWN>", "<UP>", "DIGIT", "POSDIGIT", "SIGN", "BAREINT", "INTEGER", "POINT", "EXPPART", "FLOAT", "NUMBER", "BIND", "IF", "DO", "LPAREN", "RPAREN", "LSQUARE", "RSQUARE", "LBRACE", "RBRACE", "SEPR", "DOT", "ASSIGN", "OR", "AND", "NOT", "EQ", "NEQ", "GT", "LT", "GEQ", "LEQ", "BOR", "BAND", "BXOR", "TWIDDLE", "MUL", "DIV", "PLUS", "MINUS", "MOD", "TERN_IF", "COLON", "LETTER", "UNDERSCORE", "QUOTE", "DQUOTE", "SPACE", "NEWLINE", "PUNCT", "STRING", "BARESYM", "QUOTSYM", "DOTSYM", "SYMBOL", "DOLLAR", "DOLLARSYM", "WS", "Tokens", "UNOP", "BINOP", "TERNOP", "METH", "ARRAY", "NUM_LIT", "STRING_LIT"
+ "<invalid>", "<EOR>", "<DOWN>", "<UP>", "DIGIT", "POSDIGIT", "SIGN", "BAREINT", "INTEGER", "POINT", "EXPPART", "FLOAT", "NUMBER", "BIND", "IF", "DO", "RULE", "CLASS", "METHOD", "LINE", "ENDRULE", "NOTHING", "TRUE", "FALSE", "LPAREN", "RPAREN", "LSQUARE", "RSQUARE", "LBRACE", "RBRACE", "SEPR", "DOT", "ASSIGN", "OR", "AND", "NOT", "EQ", "NEQ", "GT", "LT", "GEQ", "LEQ", "BOR", "BAND", "BXOR", "TWIDDLE", "MUL", "DIV", "PLUS", "MINUS", "MOD", "TERN_IF", "COLON", "LETTER", "UNDERSCORE", "QUOTE", "DQUOTE", "SPACE", "NEWLINE", "PUNCT", "STRING", "BARESYM", "QUOTSYM", "DOTSYM", "SYMBOL", "DOLLAR", "DOLLARSYM", "WS", "Tokens", "UNOP", "BINOP", "TERNOP", "METH", "ARRAY", "NUM_LIT", "STRING_LIT"
};
- public static final int MINUS=41;
- public static final int ARRAY=65;
+ public static final int MINUS=49;
+ public static final int ARRAY=73;
public static final int NUMBER=12;
+ public static final int FALSE=23;
+ public static final int METHOD=18;
public static final int FLOAT=11;
public static final int POSDIGIT=5;
- public static final int TWIDDLE=37;
- public static final int LEQ=33;
- public static final int MOD=42;
- public static final int GEQ=32;
- public static final int DQUOTE=48;
- public static final int BOR=34;
- public static final int OR=25;
- public static final int STRING_LIT=67;
+ public static final int LEQ=41;
+ public static final int TWIDDLE=45;
+ public static final int RULE=16;
+ public static final int MOD=50;
+ public static final int GEQ=40;
+ public static final int DQUOTE=56;
+ public static final int BOR=42;
+ public static final int OR=33;
+ public static final int STRING_LIT=75;
public static final int BAREINT=7;
- public static final int LBRACE=20;
- public static final int DOT=23;
- public static final int NEWLINE=50;
- public static final int RBRACE=21;
+ public static final int LBRACE=28;
+ public static final int NEWLINE=58;
+ public static final int DOT=31;
+ public static final int RBRACE=29;
public static final int INTEGER=8;
- public static final int AND=26;
- public static final int NUM_LIT=66;
- public static final int ASSIGN=24;
- public static final int SYMBOL=56;
- public static final int RPAREN=17;
- public static final int LPAREN=16;
+ public static final int AND=34;
+ public static final int NUM_LIT=74;
+ public static final int ASSIGN=32;
+ public static final int SYMBOL=64;
+ public static final int RPAREN=25;
public static final int SIGN=6;
- public static final int METH=64;
+ public static final int LPAREN=24;
+ public static final int METH=72;
+ public static final int PLUS=48;
public static final int DIGIT=4;
- public static final int PLUS=40;
- public static final int BINOP=62;
- public static final int BAND=35;
- public static final int NEQ=29;
- public static final int TERNOP=63;
- public static final int SPACE=49;
- public static final int LETTER=45;
- public static final int LSQUARE=18;
+ public static final int LINE=19;
+ public static final int BINOP=70;
+ public static final int BAND=43;
+ public static final int NEQ=37;
+ public static final int TERNOP=71;
+ public static final int SPACE=57;
+ public static final int LETTER=53;
+ public static final int LSQUARE=26;
public static final int DO=15;
public static final int POINT=9;
- public static final int BARESYM=53;
- public static final int SEPR=22;
- public static final int WS=59;
- public static final int STRING=52;
- public static final int EQ=28;
- public static final int QUOTSYM=54;
- public static final int LT=31;
- public static final int GT=30;
- public static final int DOLLAR=57;
- public static final int RSQUARE=19;
- public static final int TERN_IF=43;
- public static final int QUOTE=47;
- public static final int UNOP=61;
- public static final int MUL=38;
+ public static final int BARESYM=61;
+ public static final int NOTHING=21;
+ public static final int SEPR=30;
+ public static final int WS=67;
+ public static final int EQ=36;
+ public static final int STRING=60;
+ public static final int QUOTSYM=62;
+ public static final int LT=39;
+ public static final int GT=38;
+ public static final int DOLLAR=65;
+ public static final int RSQUARE=27;
+ public static final int TERN_IF=51;
+ public static final int QUOTE=55;
+ public static final int UNOP=69;
+ public static final int CLASS=17;
+ public static final int MUL=46;
public static final int EXPPART=10;
- public static final int PUNCT=51;
+ public static final int PUNCT=59;
public static final int IF=14;
public static final int EOF=-1;
- public static final int Tokens=60;
- public static final int COLON=44;
- public static final int DIV=39;
- public static final int DOTSYM=55;
- public static final int BXOR=36;
+ public static final int Tokens=68;
+ public static final int COLON=52;
+ public static final int DIV=47;
+ public static final int DOTSYM=63;
+ public static final int BXOR=44;
+ public static final int ENDRULE=20;
public static final int BIND=13;
- public static final int NOT=27;
- public static final int UNDERSCORE=46;
- public static final int DOLLARSYM=58;
+ public static final int NOT=35;
+ public static final int TRUE=22;
+ public static final int UNDERSCORE=54;
+ public static final int DOLLARSYM=66;
public ECAGrammarParser(TokenStream input) {
super(input);
- ruleMemo = new HashMap[54+1];
+ ruleMemo = new HashMap[59+1];
}
protected TreeAdaptor adaptor = new CommonTreeAdaptor();
@@ -100,38 +108,301 @@
public String getGrammarFileName() { return "dd/grammar/ECAGrammar.g"; }
+ public static class eca_script_rule_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start eca_script_rule
+ // dd/grammar/ECAGrammar.g:26:1: eca_script_rule : rule= eca_script_rule_one EOF -> ^( $rule) ;
+ public final eca_script_rule_return eca_script_rule() throws RecognitionException {
+ eca_script_rule_return retval = new eca_script_rule_return();
+ retval.start = input.LT(1);
+
+ Object root_0 = null;
+
+ Token EOF1=null;
+ eca_script_rule_one_return rule = null;
+
+
+ Object EOF1_tree=null;
+ RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
+ RewriteRuleSubtreeStream stream_eca_script_rule_one=new RewriteRuleSubtreeStream(adaptor,"rule eca_script_rule_one");
+ try {
+ // dd/grammar/ECAGrammar.g:26:17: (rule= eca_script_rule_one EOF -> ^( $rule) )
+ // dd/grammar/ECAGrammar.g:26:19: rule= eca_script_rule_one EOF
+ {
+ pushFollow(FOLLOW_eca_script_rule_one_in_eca_script_rule88);
+ rule=eca_script_rule_one();
+ _fsp--;
+ if (failed) return retval;
+ if ( backtracking==0 ) stream_eca_script_rule_one.add(rule.getTree());
+ EOF1=(Token)input.LT(1);
+ match(input,EOF,FOLLOW_EOF_in_eca_script_rule90); if (failed) return retval;
+ if ( backtracking==0 ) stream_EOF.add(EOF1);
+
+
+ // AST REWRITE
+ // elements: rule
+ // token labels:
+ // rule labels: rule, retval
+ // token list labels:
+ // rule list labels:
+ if ( backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_rule=new RewriteRuleSubtreeStream(adaptor,"token rule",rule!=null?rule.tree:null);
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 26:48: -> ^( $rule)
+ {
+ // dd/grammar/ECAGrammar.g:26:51: ^( $rule)
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(stream_rule.nextNode(), root_1);
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ }
+
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( backtracking==0 ) {
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end eca_script_rule
+
+ public static class eca_script_rule_one_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+ // $ANTLR start eca_script_rule_one
+ // dd/grammar/ECAGrammar.g:28:1: eca_script_rule_one : RULE n= SYMBOL CLASS cl= SYMBOL METHOD m= SYMBOL LINE l= NUMBER BIND e= event IF c= condition DO a= action ENDRULE -> ^( RULE $n $cl $m $l $e $c $a) ;
+ public final eca_script_rule_one_return eca_script_rule_one() throws RecognitionException {
+ eca_script_rule_one_return retval = new eca_script_rule_one_return();
+ retval.start = input.LT(1);
+
+ Object root_0 = null;
+
+ Token n=null;
+ Token cl=null;
+ Token m=null;
+ Token l=null;
+ Token RULE2=null;
+ Token CLASS3=null;
+ Token METHOD4=null;
+ Token LINE5=null;
+ Token BIND6=null;
+ Token IF7=null;
+ Token DO8=null;
+ Token ENDRULE9=null;
+ event_return e = null;
+
+ condition_return c = null;
+
+ action_return a = null;
+
+
+ Object n_tree=null;
+ Object cl_tree=null;
+ Object m_tree=null;
+ Object l_tree=null;
+ Object RULE2_tree=null;
+ Object CLASS3_tree=null;
+ Object METHOD4_tree=null;
+ Object LINE5_tree=null;
+ Object BIND6_tree=null;
+ Object IF7_tree=null;
+ Object DO8_tree=null;
+ Object ENDRULE9_tree=null;
+ RewriteRuleTokenStream stream_CLASS=new RewriteRuleTokenStream(adaptor,"token CLASS");
+ RewriteRuleTokenStream stream_RULE=new RewriteRuleTokenStream(adaptor,"token RULE");
+ RewriteRuleTokenStream stream_DO=new RewriteRuleTokenStream(adaptor,"token DO");
+ RewriteRuleTokenStream stream_LINE=new RewriteRuleTokenStream(adaptor,"token LINE");
+ RewriteRuleTokenStream stream_ENDRULE=new RewriteRuleTokenStream(adaptor,"token ENDRULE");
+ RewriteRuleTokenStream stream_BIND=new RewriteRuleTokenStream(adaptor,"token BIND");
+ RewriteRuleTokenStream stream_IF=new RewriteRuleTokenStream(adaptor,"token IF");
+ RewriteRuleTokenStream stream_NUMBER=new RewriteRuleTokenStream(adaptor,"token NUMBER");
+ RewriteRuleTokenStream stream_SYMBOL=new RewriteRuleTokenStream(adaptor,"token SYMBOL");
+ RewriteRuleTokenStream stream_METHOD=new RewriteRuleTokenStream(adaptor,"token METHOD");
+ RewriteRuleSubtreeStream stream_action=new RewriteRuleSubtreeStream(adaptor,"rule action");
+ RewriteRuleSubtreeStream stream_event=new RewriteRuleSubtreeStream(adaptor,"rule event");
+ RewriteRuleSubtreeStream stream_condition=new RewriteRuleSubtreeStream(adaptor,"rule condition");
+ try {
+ // dd/grammar/ECAGrammar.g:29:2: ( RULE n= SYMBOL CLASS cl= SYMBOL METHOD m= SYMBOL LINE l= NUMBER BIND e= event IF c= condition DO a= action ENDRULE -> ^( RULE $n $cl $m $l $e $c $a) )
+ // dd/grammar/ECAGrammar.g:29:4: RULE n= SYMBOL CLASS cl= SYMBOL METHOD m= SYMBOL LINE l= NUMBER BIND e= event IF c= condition DO a= action ENDRULE
+ {
+ RULE2=(Token)input.LT(1);
+ match(input,RULE,FOLLOW_RULE_in_eca_script_rule_one107); if (failed) return retval;
+ if ( backtracking==0 ) stream_RULE.add(RULE2);
+
+ n=(Token)input.LT(1);
+ match(input,SYMBOL,FOLLOW_SYMBOL_in_eca_script_rule_one111); if (failed) return retval;
+ if ( backtracking==0 ) stream_SYMBOL.add(n);
+
+ CLASS3=(Token)input.LT(1);
+ match(input,CLASS,FOLLOW_CLASS_in_eca_script_rule_one115); if (failed) return retval;
+ if ( backtracking==0 ) stream_CLASS.add(CLASS3);
+
+ cl=(Token)input.LT(1);
+ match(input,SYMBOL,FOLLOW_SYMBOL_in_eca_script_rule_one119); if (failed) return retval;
+ if ( backtracking==0 ) stream_SYMBOL.add(cl);
+
+ METHOD4=(Token)input.LT(1);
+ match(input,METHOD,FOLLOW_METHOD_in_eca_script_rule_one123); if (failed) return retval;
+ if ( backtracking==0 ) stream_METHOD.add(METHOD4);
+
+ m=(Token)input.LT(1);
+ match(input,SYMBOL,FOLLOW_SYMBOL_in_eca_script_rule_one127); if (failed) return retval;
+ if ( backtracking==0 ) stream_SYMBOL.add(m);
+
+ LINE5=(Token)input.LT(1);
+ match(input,LINE,FOLLOW_LINE_in_eca_script_rule_one131); if (failed) return retval;
+ if ( backtracking==0 ) stream_LINE.add(LINE5);
+
+ l=(Token)input.LT(1);
+ match(input,NUMBER,FOLLOW_NUMBER_in_eca_script_rule_one135); if (failed) return retval;
+ if ( backtracking==0 ) stream_NUMBER.add(l);
+
+ BIND6=(Token)input.LT(1);
+ match(input,BIND,FOLLOW_BIND_in_eca_script_rule_one139); if (failed) return retval;
+ if ( backtracking==0 ) stream_BIND.add(BIND6);
+
+ pushFollow(FOLLOW_event_in_eca_script_rule_one143);
+ e=event();
+ _fsp--;
+ if (failed) return retval;
+ if ( backtracking==0 ) stream_event.add(e.getTree());
+ IF7=(Token)input.LT(1);
+ match(input,IF,FOLLOW_IF_in_eca_script_rule_one147); if (failed) return retval;
+ if ( backtracking==0 ) stream_IF.add(IF7);
+
+ pushFollow(FOLLOW_condition_in_eca_script_rule_one151);
+ c=condition();
+ _fsp--;
+ if (failed) return retval;
+ if ( backtracking==0 ) stream_condition.add(c.getTree());
+ DO8=(Token)input.LT(1);
+ match(input,DO,FOLLOW_DO_in_eca_script_rule_one155); if (failed) return retval;
+ if ( backtracking==0 ) stream_DO.add(DO8);
+
+ pushFollow(FOLLOW_action_in_eca_script_rule_one159);
+ a=action();
+ _fsp--;
+ if (failed) return retval;
+ if ( backtracking==0 ) stream_action.add(a.getTree());
+ ENDRULE9=(Token)input.LT(1);
+ match(input,ENDRULE,FOLLOW_ENDRULE_in_eca_script_rule_one163); if (failed) return retval;
+ if ( backtracking==0 ) stream_ENDRULE.add(ENDRULE9);
+
+
+ // AST REWRITE
+ // elements: e, n, c, l, a, RULE, m, cl
+ // token labels: cl, m, n, l
+ // rule labels: a, c, retval, e
+ // token list labels:
+ // rule list labels:
+ if ( backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleTokenStream stream_cl=new RewriteRuleTokenStream(adaptor,"token cl",cl);
+ RewriteRuleTokenStream stream_m=new RewriteRuleTokenStream(adaptor,"token m",m);
+ RewriteRuleTokenStream stream_n=new RewriteRuleTokenStream(adaptor,"token n",n);
+ RewriteRuleTokenStream stream_l=new RewriteRuleTokenStream(adaptor,"token l",l);
+ RewriteRuleSubtreeStream stream_a=new RewriteRuleSubtreeStream(adaptor,"token a",a!=null?a.tree:null);
+ RewriteRuleSubtreeStream stream_c=new RewriteRuleSubtreeStream(adaptor,"token c",c!=null?c.tree:null);
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
+ RewriteRuleSubtreeStream stream_e=new RewriteRuleSubtreeStream(adaptor,"token e",e!=null?e.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 36:12: -> ^( RULE $n $cl $m $l $e $c $a)
+ {
+ // dd/grammar/ECAGrammar.g:36:15: ^( RULE $n $cl $m $l $e $c $a)
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(stream_RULE.next(), root_1);
+
+ adaptor.addChild(root_1, stream_n.next());
+ adaptor.addChild(root_1, stream_cl.next());
+ adaptor.addChild(root_1, stream_m.next());
+ adaptor.addChild(root_1, stream_l.next());
+ adaptor.addChild(root_1, stream_e.next());
+ adaptor.addChild(root_1, stream_c.next());
+ adaptor.addChild(root_1, stream_a.next());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ }
+
+ }
+
+ retval.stop = input.LT(-1);
+
+ if ( backtracking==0 ) {
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return retval;
+ }
+ // $ANTLR end eca_script_rule_one
+
public static class eca_rule_return extends ParserRuleReturnScope {
Object tree;
public Object getTree() { return tree; }
};
// $ANTLR start eca_rule
- // dd/grammar/ECAGrammar.g:26:1: eca_rule : eca EOF -> ^( eca ) ;
+ // dd/grammar/ECAGrammar.g:38:1: eca_rule : eca EOF -> ^( eca ) ;
public final eca_rule_return eca_rule() throws RecognitionException {
eca_rule_return retval = new eca_rule_return();
retval.start = input.LT(1);
Object root_0 = null;
- Token EOF2=null;
- eca_return eca1 = null;
+ Token EOF11=null;
+ eca_return eca10 = null;
- Object EOF2_tree=null;
+ Object EOF11_tree=null;
RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
RewriteRuleSubtreeStream stream_eca=new RewriteRuleSubtreeStream(adaptor,"rule eca");
try {
- // dd/grammar/ECAGrammar.g:26:10: ( eca EOF -> ^( eca ) )
- // dd/grammar/ECAGrammar.g:26:12: eca EOF
+ // dd/grammar/ECAGrammar.g:38:10: ( eca EOF -> ^( eca ) )
+ // dd/grammar/ECAGrammar.g:38:12: eca EOF
{
- pushFollow(FOLLOW_eca_in_eca_rule86);
- eca1=eca();
+ pushFollow(FOLLOW_eca_in_eca_rule200);
+ eca10=eca();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) stream_eca.add(eca1.getTree());
- EOF2=(Token)input.LT(1);
- match(input,EOF,FOLLOW_EOF_in_eca_rule88); if (failed) return retval;
- if ( backtracking==0 ) stream_EOF.add(EOF2);
+ if ( backtracking==0 ) stream_eca.add(eca10.getTree());
+ EOF11=(Token)input.LT(1);
+ match(input,EOF,FOLLOW_EOF_in_eca_rule202); if (failed) return retval;
+ if ( backtracking==0 ) stream_EOF.add(EOF11);
// AST REWRITE
@@ -145,9 +416,9 @@
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
root_0 = (Object)adaptor.nil();
- // 26:20: -> ^( eca )
+ // 38:20: -> ^( eca )
{
- // dd/grammar/ECAGrammar.g:26:23: ^( eca )
+ // dd/grammar/ECAGrammar.g:38:23: ^( eca )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_eca.nextNode(), root_1);
@@ -184,32 +455,32 @@
};
// $ANTLR start eca_event
- // dd/grammar/ECAGrammar.g:29:1: eca_event : event EOF -> ^( event ) ;
+ // dd/grammar/ECAGrammar.g:41:1: eca_event : event EOF -> ^( event ) ;
public final eca_event_return eca_event() throws RecognitionException {
eca_event_return retval = new eca_event_return();
retval.start = input.LT(1);
Object root_0 = null;
- Token EOF4=null;
- event_return event3 = null;
+ Token EOF13=null;
+ event_return event12 = null;
- Object EOF4_tree=null;
+ Object EOF13_tree=null;
RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
RewriteRuleSubtreeStream stream_event=new RewriteRuleSubtreeStream(adaptor,"rule event");
try {
- // dd/grammar/ECAGrammar.g:29:11: ( event EOF -> ^( event ) )
- // dd/grammar/ECAGrammar.g:29:13: event EOF
+ // dd/grammar/ECAGrammar.g:41:11: ( event EOF -> ^( event ) )
+ // dd/grammar/ECAGrammar.g:41:13: event EOF
{
- pushFollow(FOLLOW_event_in_eca_event105);
- event3=event();
+ pushFollow(FOLLOW_event_in_eca_event219);
+ event12=event();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) stream_event.add(event3.getTree());
- EOF4=(Token)input.LT(1);
- match(input,EOF,FOLLOW_EOF_in_eca_event107); if (failed) return retval;
- if ( backtracking==0 ) stream_EOF.add(EOF4);
+ if ( backtracking==0 ) stream_event.add(event12.getTree());
+ EOF13=(Token)input.LT(1);
+ match(input,EOF,FOLLOW_EOF_in_eca_event221); if (failed) return retval;
+ if ( backtracking==0 ) stream_EOF.add(EOF13);
// AST REWRITE
@@ -223,9 +494,9 @@
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
root_0 = (Object)adaptor.nil();
- // 29:23: -> ^( event )
+ // 41:23: -> ^( event )
{
- // dd/grammar/ECAGrammar.g:29:26: ^( event )
+ // dd/grammar/ECAGrammar.g:41:26: ^( event )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_event.nextNode(), root_1);
@@ -262,32 +533,32 @@
};
// $ANTLR start eca_condition
- // dd/grammar/ECAGrammar.g:32:1: eca_condition : condition EOF -> ^( condition ) ;
+ // dd/grammar/ECAGrammar.g:44:1: eca_condition : condition EOF -> ^( condition ) ;
public final eca_condition_return eca_condition() throws RecognitionException {
eca_condition_return retval = new eca_condition_return();
retval.start = input.LT(1);
Object root_0 = null;
- Token EOF6=null;
- condition_return condition5 = null;
+ Token EOF15=null;
+ condition_return condition14 = null;
- Object EOF6_tree=null;
+ Object EOF15_tree=null;
RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
RewriteRuleSubtreeStream stream_condition=new RewriteRuleSubtreeStream(adaptor,"rule condition");
try {
- // dd/grammar/ECAGrammar.g:32:15: ( condition EOF -> ^( condition ) )
- // dd/grammar/ECAGrammar.g:32:17: condition EOF
+ // dd/grammar/ECAGrammar.g:44:15: ( condition EOF -> ^( condition ) )
+ // dd/grammar/ECAGrammar.g:44:17: condition EOF
{
- pushFollow(FOLLOW_condition_in_eca_condition123);
- condition5=condition();
+ pushFollow(FOLLOW_condition_in_eca_condition237);
+ condition14=condition();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) stream_condition.add(condition5.getTree());
- EOF6=(Token)input.LT(1);
- match(input,EOF,FOLLOW_EOF_in_eca_condition125); if (failed) return retval;
- if ( backtracking==0 ) stream_EOF.add(EOF6);
+ if ( backtracking==0 ) stream_condition.add(condition14.getTree());
+ EOF15=(Token)input.LT(1);
+ match(input,EOF,FOLLOW_EOF_in_eca_condition239); if (failed) return retval;
+ if ( backtracking==0 ) stream_EOF.add(EOF15);
// AST REWRITE
@@ -301,9 +572,9 @@
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
root_0 = (Object)adaptor.nil();
- // 32:31: -> ^( condition )
+ // 44:31: -> ^( condition )
{
- // dd/grammar/ECAGrammar.g:32:34: ^( condition )
+ // dd/grammar/ECAGrammar.g:44:34: ^( condition )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_condition.nextNode(), root_1);
@@ -340,32 +611,32 @@
};
// $ANTLR start eca_action
- // dd/grammar/ECAGrammar.g:35:1: eca_action : action EOF -> ^( action ) ;
+ // dd/grammar/ECAGrammar.g:47:1: eca_action : action EOF -> ^( action ) ;
public final eca_action_return eca_action() throws RecognitionException {
eca_action_return retval = new eca_action_return();
retval.start = input.LT(1);
Object root_0 = null;
- Token EOF8=null;
- action_return action7 = null;
+ Token EOF17=null;
+ action_return action16 = null;
- Object EOF8_tree=null;
+ Object EOF17_tree=null;
RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
RewriteRuleSubtreeStream stream_action=new RewriteRuleSubtreeStream(adaptor,"rule action");
try {
- // dd/grammar/ECAGrammar.g:35:12: ( action EOF -> ^( action ) )
- // dd/grammar/ECAGrammar.g:35:14: action EOF
+ // dd/grammar/ECAGrammar.g:47:12: ( action EOF -> ^( action ) )
+ // dd/grammar/ECAGrammar.g:47:14: action EOF
{
- pushFollow(FOLLOW_action_in_eca_action141);
- action7=action();
+ pushFollow(FOLLOW_action_in_eca_action255);
+ action16=action();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) stream_action.add(action7.getTree());
- EOF8=(Token)input.LT(1);
- match(input,EOF,FOLLOW_EOF_in_eca_action143); if (failed) return retval;
- if ( backtracking==0 ) stream_EOF.add(EOF8);
+ if ( backtracking==0 ) stream_action.add(action16.getTree());
+ EOF17=(Token)input.LT(1);
+ match(input,EOF,FOLLOW_EOF_in_eca_action257); if (failed) return retval;
+ if ( backtracking==0 ) stream_EOF.add(EOF17);
// AST REWRITE
@@ -379,9 +650,9 @@
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
root_0 = (Object)adaptor.nil();
- // 35:25: -> ^( action )
+ // 47:25: -> ^( action )
{
- // dd/grammar/ECAGrammar.g:35:28: ^( action )
+ // dd/grammar/ECAGrammar.g:47:28: ^( action )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_action.nextNode(), root_1);
@@ -418,16 +689,16 @@
};
// $ANTLR start eca
- // dd/grammar/ECAGrammar.g:38:1: eca : BIND e= event IF c= condition DO a= action -> ^( BIND $e $c $a) ;
+ // dd/grammar/ECAGrammar.g:50:1: eca : BIND e= event IF c= condition DO a= action -> ^( BIND $e $c $a) ;
public final eca_return eca() throws RecognitionException {
eca_return retval = new eca_return();
retval.start = input.LT(1);
Object root_0 = null;
- Token BIND9=null;
- Token IF10=null;
- Token DO11=null;
+ Token BIND18=null;
+ Token IF19=null;
+ Token DO20=null;
event_return e = null;
condition_return c = null;
@@ -435,9 +706,9 @@
action_return a = null;
- Object BIND9_tree=null;
- Object IF10_tree=null;
- Object DO11_tree=null;
+ Object BIND18_tree=null;
+ Object IF19_tree=null;
+ Object DO20_tree=null;
RewriteRuleTokenStream stream_DO=new RewriteRuleTokenStream(adaptor,"token DO");
RewriteRuleTokenStream stream_BIND=new RewriteRuleTokenStream(adaptor,"token BIND");
RewriteRuleTokenStream stream_IF=new RewriteRuleTokenStream(adaptor,"token IF");
@@ -445,39 +716,39 @@
RewriteRuleSubtreeStream stream_event=new RewriteRuleSubtreeStream(adaptor,"rule event");
RewriteRuleSubtreeStream stream_condition=new RewriteRuleSubtreeStream(adaptor,"rule condition");
try {
- // dd/grammar/ECAGrammar.g:38:5: ( BIND e= event IF c= condition DO a= action -> ^( BIND $e $c $a) )
- // dd/grammar/ECAGrammar.g:38:7: BIND e= event IF c= condition DO a= action
+ // dd/grammar/ECAGrammar.g:50:5: ( BIND e= event IF c= condition DO a= action -> ^( BIND $e $c $a) )
+ // dd/grammar/ECAGrammar.g:50:7: BIND e= event IF c= condition DO a= action
{
- BIND9=(Token)input.LT(1);
- match(input,BIND,FOLLOW_BIND_in_eca159); if (failed) return retval;
- if ( backtracking==0 ) stream_BIND.add(BIND9);
+ BIND18=(Token)input.LT(1);
+ match(input,BIND,FOLLOW_BIND_in_eca273); if (failed) return retval;
+ if ( backtracking==0 ) stream_BIND.add(BIND18);
- pushFollow(FOLLOW_event_in_eca163);
+ pushFollow(FOLLOW_event_in_eca277);
e=event();
_fsp--;
if (failed) return retval;
if ( backtracking==0 ) stream_event.add(e.getTree());
- IF10=(Token)input.LT(1);
- match(input,IF,FOLLOW_IF_in_eca167); if (failed) return retval;
- if ( backtracking==0 ) stream_IF.add(IF10);
+ IF19=(Token)input.LT(1);
+ match(input,IF,FOLLOW_IF_in_eca281); if (failed) return retval;
+ if ( backtracking==0 ) stream_IF.add(IF19);
- pushFollow(FOLLOW_condition_in_eca171);
+ pushFollow(FOLLOW_condition_in_eca285);
c=condition();
_fsp--;
if (failed) return retval;
if ( backtracking==0 ) stream_condition.add(c.getTree());
- DO11=(Token)input.LT(1);
- match(input,DO,FOLLOW_DO_in_eca175); if (failed) return retval;
- if ( backtracking==0 ) stream_DO.add(DO11);
+ DO20=(Token)input.LT(1);
+ match(input,DO,FOLLOW_DO_in_eca289); if (failed) return retval;
+ if ( backtracking==0 ) stream_DO.add(DO20);
- pushFollow(FOLLOW_action_in_eca179);
+ pushFollow(FOLLOW_action_in_eca293);
a=action();
_fsp--;
if (failed) return retval;
if ( backtracking==0 ) stream_action.add(a.getTree());
// AST REWRITE
- // elements: e, BIND, c, a
+ // elements: c, e, a, BIND
// token labels:
// rule labels: a, c, retval, e
// token list labels:
@@ -490,9 +761,9 @@
RewriteRuleSubtreeStream stream_e=new RewriteRuleSubtreeStream(adaptor,"token e",e!=null?e.tree:null);
root_0 = (Object)adaptor.nil();
- // 40:15: -> ^( BIND $e $c $a)
+ // 52:15: -> ^( BIND $e $c $a)
{
- // dd/grammar/ECAGrammar.g:40:18: ^( BIND $e $c $a)
+ // dd/grammar/ECAGrammar.g:52:18: ^( BIND $e $c $a)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_BIND.next(), root_1);
@@ -533,28 +804,28 @@
};
// $ANTLR start event
- // dd/grammar/ECAGrammar.g:45:1: event : bindings ;
+ // dd/grammar/ECAGrammar.g:57:1: event : bindings ;
public final event_return event() throws RecognitionException {
event_return retval = new event_return();
retval.start = input.LT(1);
Object root_0 = null;
- bindings_return bindings12 = null;
+ bindings_return bindings21 = null;
try {
- // dd/grammar/ECAGrammar.g:45:7: ( bindings )
- // dd/grammar/ECAGrammar.g:45:9: bindings
+ // dd/grammar/ECAGrammar.g:57:7: ( bindings )
+ // dd/grammar/ECAGrammar.g:57:9: bindings
{
root_0 = (Object)adaptor.nil();
- pushFollow(FOLLOW_bindings_in_event206);
- bindings12=bindings();
+ pushFollow(FOLLOW_bindings_in_event320);
+ bindings21=bindings();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) adaptor.addChild(root_0, bindings12.getTree());
+ if ( backtracking==0 ) adaptor.addChild(root_0, bindings21.getTree());
}
@@ -581,27 +852,27 @@
};
// $ANTLR start bindings
- // dd/grammar/ECAGrammar.g:50:1: bindings : ( binding SEPR bindings -> ^( SEPR binding bindings ) | binding );
+ // dd/grammar/ECAGrammar.g:62:1: bindings : ( binding SEPR bindings -> ^( SEPR binding bindings ) | binding );
public final bindings_return bindings() throws RecognitionException {
bindings_return retval = new bindings_return();
retval.start = input.LT(1);
Object root_0 = null;
- Token SEPR14=null;
- binding_return binding13 = null;
+ Token SEPR23=null;
+ binding_return binding22 = null;
- bindings_return bindings15 = null;
+ bindings_return bindings24 = null;
- binding_return binding16 = null;
+ binding_return binding25 = null;
- Object SEPR14_tree=null;
+ Object SEPR23_tree=null;
RewriteRuleTokenStream stream_SEPR=new RewriteRuleTokenStream(adaptor,"token SEPR");
RewriteRuleSubtreeStream stream_bindings=new RewriteRuleSubtreeStream(adaptor,"rule bindings");
RewriteRuleSubtreeStream stream_binding=new RewriteRuleSubtreeStream(adaptor,"rule binding");
try {
- // dd/grammar/ECAGrammar.g:50:10: ( binding SEPR bindings -> ^( SEPR binding bindings ) | binding )
+ // dd/grammar/ECAGrammar.g:62:10: ( binding SEPR bindings -> ^( SEPR binding bindings ) | binding )
int alt1=2;
int LA1_0 = input.LA(1);
@@ -617,7 +888,7 @@
else {
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("50:1: bindings : ( binding SEPR bindings -> ^( SEPR binding bindings ) | binding );", 1, 1, input);
+ new NoViableAltException("62:1: bindings : ( binding SEPR bindings -> ^( SEPR binding bindings ) | binding );", 1, 1, input);
throw nvae;
}
@@ -625,31 +896,31 @@
else {
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("50:1: bindings : ( binding SEPR bindings -> ^( SEPR binding bindings ) | binding );", 1, 0, input);
+ new NoViableAltException("62:1: bindings : ( binding SEPR bindings -> ^( SEPR binding bindings ) | binding );", 1, 0, input);
throw nvae;
}
switch (alt1) {
case 1 :
- // dd/grammar/ECAGrammar.g:50:12: binding SEPR bindings
+ // dd/grammar/ECAGrammar.g:62:12: binding SEPR bindings
{
- pushFollow(FOLLOW_binding_in_bindings218);
- binding13=binding();
+ pushFollow(FOLLOW_binding_in_bindings332);
+ binding22=binding();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) stream_binding.add(binding13.getTree());
- SEPR14=(Token)input.LT(1);
- match(input,SEPR,FOLLOW_SEPR_in_bindings220); if (failed) return retval;
- if ( backtracking==0 ) stream_SEPR.add(SEPR14);
+ if ( backtracking==0 ) stream_binding.add(binding22.getTree());
+ SEPR23=(Token)input.LT(1);
+ match(input,SEPR,FOLLOW_SEPR_in_bindings334); if (failed) return retval;
+ if ( backtracking==0 ) stream_SEPR.add(SEPR23);
- pushFollow(FOLLOW_bindings_in_bindings222);
- bindings15=bindings();
+ pushFollow(FOLLOW_bindings_in_bindings336);
+ bindings24=bindings();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) stream_bindings.add(bindings15.getTree());
+ if ( backtracking==0 ) stream_bindings.add(bindings24.getTree());
// AST REWRITE
- // elements: bindings, SEPR, binding
+ // elements: binding, SEPR, bindings
// token labels:
// rule labels: retval
// token list labels:
@@ -659,9 +930,9 @@
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
root_0 = (Object)adaptor.nil();
- // 50:34: -> ^( SEPR binding bindings )
+ // 62:34: -> ^( SEPR binding bindings )
{
- // dd/grammar/ECAGrammar.g:50:37: ^( SEPR binding bindings )
+ // dd/grammar/ECAGrammar.g:62:37: ^( SEPR binding bindings )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_SEPR.next(), root_1);
@@ -679,15 +950,15 @@
}
break;
case 2 :
- // dd/grammar/ECAGrammar.g:51:4: binding
+ // dd/grammar/ECAGrammar.g:63:4: binding
{
root_0 = (Object)adaptor.nil();
- pushFollow(FOLLOW_binding_in_bindings237);
- binding16=binding();
+ pushFollow(FOLLOW_binding_in_bindings351);
+ binding25=binding();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) adaptor.addChild(root_0, binding16.getTree());
+ if ( backtracking==0 ) adaptor.addChild(root_0, binding25.getTree());
}
break;
@@ -716,41 +987,41 @@
};
// $ANTLR start binding
- // dd/grammar/ECAGrammar.g:54:1: binding : bind_sym ASSIGN expr -> ^( ASSIGN bind_sym expr ) ;
+ // dd/grammar/ECAGrammar.g:66:1: binding : bind_sym ASSIGN expr -> ^( ASSIGN bind_sym expr ) ;
public final binding_return binding() throws RecognitionException {
binding_return retval = new binding_return();
retval.start = input.LT(1);
Object root_0 = null;
- Token ASSIGN18=null;
- bind_sym_return bind_sym17 = null;
+ Token ASSIGN27=null;
+ bind_sym_return bind_sym26 = null;
- expr_return expr19 = null;
+ expr_return expr28 = null;
- Object ASSIGN18_tree=null;
+ Object ASSIGN27_tree=null;
RewriteRuleTokenStream stream_ASSIGN=new RewriteRuleTokenStream(adaptor,"token ASSIGN");
RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr");
RewriteRuleSubtreeStream stream_bind_sym=new RewriteRuleSubtreeStream(adaptor,"rule bind_sym");
try {
- // dd/grammar/ECAGrammar.g:54:9: ( bind_sym ASSIGN expr -> ^( ASSIGN bind_sym expr ) )
- // dd/grammar/ECAGrammar.g:54:11: bind_sym ASSIGN expr
+ // dd/grammar/ECAGrammar.g:66:9: ( bind_sym ASSIGN expr -> ^( ASSIGN bind_sym expr ) )
+ // dd/grammar/ECAGrammar.g:66:11: bind_sym ASSIGN expr
{
- pushFollow(FOLLOW_bind_sym_in_binding247);
- bind_sym17=bind_sym();
+ pushFollow(FOLLOW_bind_sym_in_binding361);
+ bind_sym26=bind_sym();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) stream_bind_sym.add(bind_sym17.getTree());
- ASSIGN18=(Token)input.LT(1);
- match(input,ASSIGN,FOLLOW_ASSIGN_in_binding249); if (failed) return retval;
- if ( backtracking==0 ) stream_ASSIGN.add(ASSIGN18);
+ if ( backtracking==0 ) stream_bind_sym.add(bind_sym26.getTree());
+ ASSIGN27=(Token)input.LT(1);
+ match(input,ASSIGN,FOLLOW_ASSIGN_in_binding363); if (failed) return retval;
+ if ( backtracking==0 ) stream_ASSIGN.add(ASSIGN27);
- pushFollow(FOLLOW_expr_in_binding251);
- expr19=expr();
+ pushFollow(FOLLOW_expr_in_binding365);
+ expr28=expr();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) stream_expr.add(expr19.getTree());
+ if ( backtracking==0 ) stream_expr.add(expr28.getTree());
// AST REWRITE
// elements: expr, bind_sym, ASSIGN
@@ -763,9 +1034,9 @@
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
root_0 = (Object)adaptor.nil();
- // 54:32: -> ^( ASSIGN bind_sym expr )
+ // 66:32: -> ^( ASSIGN bind_sym expr )
{
- // dd/grammar/ECAGrammar.g:54:35: ^( ASSIGN bind_sym expr )
+ // dd/grammar/ECAGrammar.g:66:35: ^( ASSIGN bind_sym expr )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_ASSIGN.next(), root_1);
@@ -805,7 +1076,7 @@
};
// $ANTLR start bind_sym
- // dd/grammar/ECAGrammar.g:58:1: bind_sym : (v= SYMBOL COLON t= SYMBOL -> ^( COLON $v $t) | SYMBOL );
+ // dd/grammar/ECAGrammar.g:70:1: bind_sym : (v= SYMBOL COLON t= SYMBOL -> ^( COLON $v $t) | SYMBOL );
public final bind_sym_return bind_sym() throws RecognitionException {
bind_sym_return retval = new bind_sym_return();
retval.start = input.LT(1);
@@ -814,18 +1085,18 @@
Token v=null;
Token t=null;
- Token COLON20=null;
- Token SYMBOL21=null;
+ Token COLON29=null;
+ Token SYMBOL30=null;
Object v_tree=null;
Object t_tree=null;
- Object COLON20_tree=null;
- Object SYMBOL21_tree=null;
+ Object COLON29_tree=null;
+ Object SYMBOL30_tree=null;
RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON");
RewriteRuleTokenStream stream_SYMBOL=new RewriteRuleTokenStream(adaptor,"token SYMBOL");
try {
- // dd/grammar/ECAGrammar.g:58:10: (v= SYMBOL COLON t= SYMBOL -> ^( COLON $v $t) | SYMBOL )
+ // dd/grammar/ECAGrammar.g:70:10: (v= SYMBOL COLON t= SYMBOL -> ^( COLON $v $t) | SYMBOL )
int alt2=2;
int LA2_0 = input.LA(1);
@@ -841,7 +1112,7 @@
else {
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("58:1: bind_sym : (v= SYMBOL COLON t= SYMBOL -> ^( COLON $v $t) | SYMBOL );", 2, 1, input);
+ new NoViableAltException("70:1: bind_sym : (v= SYMBOL COLON t= SYMBOL -> ^( COLON $v $t) | SYMBOL );", 2, 1, input);
throw nvae;
}
@@ -849,24 +1120,24 @@
else {
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("58:1: bind_sym : (v= SYMBOL COLON t= SYMBOL -> ^( COLON $v $t) | SYMBOL );", 2, 0, input);
+ new NoViableAltException("70:1: bind_sym : (v= SYMBOL COLON t= SYMBOL -> ^( COLON $v $t) | SYMBOL );", 2, 0, input);
throw nvae;
}
switch (alt2) {
case 1 :
- // dd/grammar/ECAGrammar.g:58:12: v= SYMBOL COLON t= SYMBOL
+ // dd/grammar/ECAGrammar.g:70:12: v= SYMBOL COLON t= SYMBOL
{
v=(Token)input.LT(1);
- match(input,SYMBOL,FOLLOW_SYMBOL_in_bind_sym274); if (failed) return retval;
+ match(input,SYMBOL,FOLLOW_SYMBOL_in_bind_sym388); if (failed) return retval;
if ( backtracking==0 ) stream_SYMBOL.add(v);
- COLON20=(Token)input.LT(1);
- match(input,COLON,FOLLOW_COLON_in_bind_sym276); if (failed) return retval;
- if ( backtracking==0 ) stream_COLON.add(COLON20);
+ COLON29=(Token)input.LT(1);
+ match(input,COLON,FOLLOW_COLON_in_bind_sym390); if (failed) return retval;
+ if ( backtracking==0 ) stream_COLON.add(COLON29);
t=(Token)input.LT(1);
- match(input,SYMBOL,FOLLOW_SYMBOL_in_bind_sym280); if (failed) return retval;
+ match(input,SYMBOL,FOLLOW_SYMBOL_in_bind_sym394); if (failed) return retval;
if ( backtracking==0 ) stream_SYMBOL.add(t);
@@ -883,9 +1154,9 @@
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
root_0 = (Object)adaptor.nil();
- // 58:36: -> ^( COLON $v $t)
+ // 70:36: -> ^( COLON $v $t)
{
- // dd/grammar/ECAGrammar.g:58:39: ^( COLON $v $t)
+ // dd/grammar/ECAGrammar.g:70:39: ^( COLON $v $t)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_COLON.next(), root_1);
@@ -903,15 +1174,15 @@
}
break;
case 2 :
- // dd/grammar/ECAGrammar.g:59:4: SYMBOL
+ // dd/grammar/ECAGrammar.g:71:4: SYMBOL
{
root_0 = (Object)adaptor.nil();
- SYMBOL21=(Token)input.LT(1);
- match(input,SYMBOL,FOLLOW_SYMBOL_in_bind_sym298); if (failed) return retval;
+ SYMBOL30=(Token)input.LT(1);
+ match(input,SYMBOL,FOLLOW_SYMBOL_in_bind_sym412); if (failed) return retval;
if ( backtracking==0 ) {
- SYMBOL21_tree = (Object)adaptor.create(SYMBOL21);
- adaptor.addChild(root_0, SYMBOL21_tree);
+ SYMBOL30_tree = (Object)adaptor.create(SYMBOL30);
+ adaptor.addChild(root_0, SYMBOL30_tree);
}
}
@@ -941,31 +1212,142 @@
};
// $ANTLR start condition
- // dd/grammar/ECAGrammar.g:66:1: condition : expr ;
+ // dd/grammar/ECAGrammar.g:78:1: condition : ( TRUE -> ^( TRUE ) | FALSE -> ^( FALSE ) | expr );
public final condition_return condition() throws RecognitionException {
condition_return retval = new condition_return();
retval.start = input.LT(1);
Object root_0 = null;
- expr_return expr22 = null;
+ Token TRUE31=null;
+ Token FALSE32=null;
+ expr_return expr33 = null;
+ Object TRUE31_tree=null;
+ Object FALSE32_tree=null;
+ RewriteRuleTokenStream stream_TRUE=new RewriteRuleTokenStream(adaptor,"token TRUE");
+ RewriteRuleTokenStream stream_FALSE=new RewriteRuleTokenStream(adaptor,"token FALSE");
try {
- // dd/grammar/ECAGrammar.g:66:11: ( expr )
- // dd/grammar/ECAGrammar.g:66:13: expr
- {
- root_0 = (Object)adaptor.nil();
+ // dd/grammar/ECAGrammar.g:78:11: ( TRUE -> ^( TRUE ) | FALSE -> ^( FALSE ) | expr )
+ int alt3=3;
+ switch ( input.LA(1) ) {
+ case TRUE:
+ {
+ alt3=1;
+ }
+ break;
+ case FALSE:
+ {
+ alt3=2;
+ }
+ break;
+ case NUMBER:
+ case LPAREN:
+ case NOT:
+ case TWIDDLE:
+ case STRING:
+ case SYMBOL:
+ case DOLLARSYM:
+ {
+ alt3=3;
+ }
+ break;
+ default:
+ if (backtracking>0) {failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("78:1: condition : ( TRUE -> ^( TRUE ) | FALSE -> ^( FALSE ) | expr );", 3, 0, input);
- pushFollow(FOLLOW_expr_in_condition312);
- expr22=expr();
- _fsp--;
- if (failed) return retval;
- if ( backtracking==0 ) adaptor.addChild(root_0, expr22.getTree());
+ throw nvae;
+ }
+ switch (alt3) {
+ case 1 :
+ // dd/grammar/ECAGrammar.g:78:13: TRUE
+ {
+ TRUE31=(Token)input.LT(1);
+ match(input,TRUE,FOLLOW_TRUE_in_condition426); if (failed) return retval;
+ if ( backtracking==0 ) stream_TRUE.add(TRUE31);
+
+
+ // AST REWRITE
+ // elements: TRUE
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ if ( backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 78:19: -> ^( TRUE )
+ {
+ // dd/grammar/ECAGrammar.g:78:22: ^( TRUE )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(stream_TRUE.next(), root_1);
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ }
+
+ }
+ break;
+ case 2 :
+ // dd/grammar/ECAGrammar.g:79:4: FALSE
+ {
+ FALSE32=(Token)input.LT(1);
+ match(input,FALSE,FOLLOW_FALSE_in_condition438); if (failed) return retval;
+ if ( backtracking==0 ) stream_FALSE.add(FALSE32);
+
+
+ // AST REWRITE
+ // elements: FALSE
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ if ( backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 79:11: -> ^( FALSE )
+ {
+ // dd/grammar/ECAGrammar.g:79:14: ^( FALSE )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(stream_FALSE.next(), root_1);
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ }
+
+ }
+ break;
+ case 3 :
+ // dd/grammar/ECAGrammar.g:80:4: expr
+ {
+ root_0 = (Object)adaptor.nil();
+
+ pushFollow(FOLLOW_expr_in_condition450);
+ expr33=expr();
+ _fsp--;
+ if (failed) return retval;
+ if ( backtracking==0 ) adaptor.addChild(root_0, expr33.getTree());
+
+ }
+ break;
+
}
-
retval.stop = input.LT(-1);
if ( backtracking==0 ) {
@@ -989,31 +1371,89 @@
};
// $ANTLR start action
- // dd/grammar/ECAGrammar.g:73:1: action : action_expr_list ;
+ // dd/grammar/ECAGrammar.g:87:1: action : ( NOTHING -> ^( NOTHING ) | action_expr_list );
public final action_return action() throws RecognitionException {
action_return retval = new action_return();
retval.start = input.LT(1);
Object root_0 = null;
- action_expr_list_return action_expr_list23 = null;
+ Token NOTHING34=null;
+ action_expr_list_return action_expr_list35 = null;
+ Object NOTHING34_tree=null;
+ RewriteRuleTokenStream stream_NOTHING=new RewriteRuleTokenStream(adaptor,"token NOTHING");
try {
- // dd/grammar/ECAGrammar.g:73:8: ( action_expr_list )
- // dd/grammar/ECAGrammar.g:73:10: action_expr_list
- {
- root_0 = (Object)adaptor.nil();
+ // dd/grammar/ECAGrammar.g:87:8: ( NOTHING -> ^( NOTHING ) | action_expr_list )
+ int alt4=2;
+ int LA4_0 = input.LA(1);
- pushFollow(FOLLOW_action_expr_list_in_action326);
- action_expr_list23=action_expr_list();
- _fsp--;
- if (failed) return retval;
- if ( backtracking==0 ) adaptor.addChild(root_0, action_expr_list23.getTree());
+ if ( (LA4_0==NOTHING) ) {
+ alt4=1;
+ }
+ else if ( (LA4_0==NUMBER||LA4_0==LPAREN||LA4_0==NOT||LA4_0==TWIDDLE||LA4_0==STRING||LA4_0==SYMBOL||LA4_0==DOLLARSYM) ) {
+ alt4=2;
+ }
+ else {
+ if (backtracking>0) {failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("87:1: action : ( NOTHING -> ^( NOTHING ) | action_expr_list );", 4, 0, input);
+ throw nvae;
}
+ switch (alt4) {
+ case 1 :
+ // dd/grammar/ECAGrammar.g:87:10: NOTHING
+ {
+ NOTHING34=(Token)input.LT(1);
+ match(input,NOTHING,FOLLOW_NOTHING_in_action464); if (failed) return retval;
+ if ( backtracking==0 ) stream_NOTHING.add(NOTHING34);
+
+ // AST REWRITE
+ // elements: NOTHING
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ if ( backtracking==0 ) {
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 87:19: -> ^( NOTHING )
+ {
+ // dd/grammar/ECAGrammar.g:87:22: ^( NOTHING )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(stream_NOTHING.next(), root_1);
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+ }
+
+ }
+ break;
+ case 2 :
+ // dd/grammar/ECAGrammar.g:88:4: action_expr_list
+ {
+ root_0 = (Object)adaptor.nil();
+
+ pushFollow(FOLLOW_action_expr_list_in_action476);
+ action_expr_list35=action_expr_list();
+ _fsp--;
+ if (failed) return retval;
+ if ( backtracking==0 ) adaptor.addChild(root_0, action_expr_list35.getTree());
+
+ }
+ break;
+
+ }
retval.stop = input.LT(-1);
if ( backtracking==0 ) {
@@ -1037,43 +1477,43 @@
};
// $ANTLR start action_expr_list
- // dd/grammar/ECAGrammar.g:76:1: action_expr_list : ( action_expr SEPR action_expr_list -> ^( SEPR action_expr action_expr_list ) | action_expr );
+ // dd/grammar/ECAGrammar.g:91:1: action_expr_list : ( action_expr SEPR action_expr_list -> ^( SEPR action_expr action_expr_list ) | action_expr );
public final action_expr_list_return action_expr_list() throws RecognitionException {
action_expr_list_return retval = new action_expr_list_return();
retval.start = input.LT(1);
Object root_0 = null;
- Token SEPR25=null;
- action_expr_return action_expr24 = null;
+ Token SEPR37=null;
+ action_expr_return action_expr36 = null;
- action_expr_list_return action_expr_list26 = null;
+ action_expr_list_return action_expr_list38 = null;
- action_expr_return action_expr27 = null;
+ action_expr_return action_expr39 = null;
- Object SEPR25_tree=null;
+ Object SEPR37_tree=null;
RewriteRuleTokenStream stream_SEPR=new RewriteRuleTokenStream(adaptor,"token SEPR");
RewriteRuleSubtreeStream stream_action_expr_list=new RewriteRuleSubtreeStream(adaptor,"rule action_expr_list");
RewriteRuleSubtreeStream stream_action_expr=new RewriteRuleSubtreeStream(adaptor,"rule action_expr");
try {
- // dd/grammar/ECAGrammar.g:77:2: ( action_expr SEPR action_expr_list -> ^( SEPR action_expr action_expr_list ) | action_expr )
- int alt3=2;
+ // dd/grammar/ECAGrammar.g:92:2: ( action_expr SEPR action_expr_list -> ^( SEPR action_expr action_expr_list ) | action_expr )
+ int alt5=2;
switch ( input.LA(1) ) {
case DOLLARSYM:
{
- int LA3_1 = input.LA(2);
+ int LA5_1 = input.LA(2);
- if ( (synpred3()) ) {
- alt3=1;
+ if ( (synpred6()) ) {
+ alt5=1;
}
else if ( (true) ) {
- alt3=2;
+ alt5=2;
}
else {
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("76:1: action_expr_list : ( action_expr SEPR action_expr_list -> ^( SEPR action_expr action_expr_list ) | action_expr );", 3, 1, input);
+ new NoViableAltException("91:1: action_expr_list : ( action_expr SEPR action_expr_list -> ^( SEPR action_expr action_expr_list ) | action_expr );", 5, 1, input);
throw nvae;
}
@@ -1081,18 +1521,18 @@
break;
case SYMBOL:
{
- int LA3_2 = input.LA(2);
+ int LA5_2 = input.LA(2);
- if ( (synpred3()) ) {
- alt3=1;
+ if ( (synpred6()) ) {
+ alt5=1;
}
else if ( (true) ) {
- alt3=2;
+ alt5=2;
}
else {
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("76:1: action_expr_list : ( action_expr SEPR action_expr_list -> ^( SEPR action_expr action_expr_list ) | action_expr );", 3, 2, input);
+ new NoViableAltException("91:1: action_expr_list : ( action_expr SEPR action_expr_list -> ^( SEPR action_expr action_expr_list ) | action_expr );", 5, 2, input);
throw nvae;
}
@@ -1100,18 +1540,18 @@
break;
case NUMBER:
{
- int LA3_3 = input.LA(2);
+ int LA5_3 = input.LA(2);
- if ( (synpred3()) ) {
- alt3=1;
+ if ( (synpred6()) ) {
+ alt5=1;
}
else if ( (true) ) {
- alt3=2;
+ alt5=2;
}
else {
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("76:1: action_expr_list : ( action_expr SEPR action_expr_list -> ^( SEPR action_expr action_expr_list ) | action_expr );", 3, 3, input);
+ new NoViableAltException("91:1: action_expr_list : ( action_expr SEPR action_expr_list -> ^( SEPR action_expr action_expr_list ) | action_expr );", 5, 3, input);
throw nvae;
}
@@ -1119,18 +1559,18 @@
break;
case STRING:
{
- int LA3_4 = input.LA(2);
+ int LA5_4 = input.LA(2);
- if ( (synpred3()) ) {
- alt3=1;
+ if ( (synpred6()) ) {
+ alt5=1;
}
else if ( (true) ) {
- alt3=2;
+ alt5=2;
}
else {
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("76:1: action_expr_list : ( action_expr SEPR action_expr_list -> ^( SEPR action_expr action_expr_list ) | action_expr );", 3, 4, input);
+ new NoViableAltException("91:1: action_expr_list : ( action_expr SEPR action_expr_list -> ^( SEPR action_expr action_expr_list ) | action_expr );", 5, 4, input);
throw nvae;
}
@@ -1138,18 +1578,18 @@
break;
case LPAREN:
{
- int LA3_5 = input.LA(2);
+ int LA5_5 = input.LA(2);
- if ( (synpred3()) ) {
- alt3=1;
+ if ( (synpred6()) ) {
+ alt5=1;
}
else if ( (true) ) {
- alt3=2;
+ alt5=2;
}
else {
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("76:1: action_expr_list : ( action_expr SEPR action_expr_list -> ^( SEPR action_expr action_expr_list ) | action_expr );", 3, 5, input);
+ new NoViableAltException("91:1: action_expr_list : ( action_expr SEPR action_expr_list -> ^( SEPR action_expr action_expr_list ) | action_expr );", 5, 5, input);
throw nvae;
}
@@ -1158,18 +1598,18 @@
case NOT:
case TWIDDLE:
{
- int LA3_6 = input.LA(2);
+ int LA5_6 = input.LA(2);
- if ( (synpred3()) ) {
- alt3=1;
+ if ( (synpred6()) ) {
+ alt5=1;
}
else if ( (true) ) {
- alt3=2;
+ alt5=2;
}
else {
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("76:1: action_expr_list : ( action_expr SEPR action_expr_list -> ^( SEPR action_expr action_expr_list ) | action_expr );", 3, 6, input);
+ new NoViableAltException("91:1: action_expr_list : ( action_expr SEPR action_expr_list -> ^( SEPR action_expr action_expr_list ) | action_expr );", 5, 6, input);
throw nvae;
}
@@ -1178,32 +1618,32 @@
default:
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("76:1: action_expr_list : ( action_expr SEPR action_expr_list -> ^( SEPR action_expr action_expr_list ) | action_expr );", 3, 0, input);
+ new NoViableAltException("91:1: action_expr_list : ( action_expr SEPR action_expr_list -> ^( SEPR action_expr action_expr_list ) | action_expr );", 5, 0, input);
throw nvae;
}
- switch (alt3) {
+ switch (alt5) {
case 1 :
- // dd/grammar/ECAGrammar.g:77:4: action_expr SEPR action_expr_list
+ // dd/grammar/ECAGrammar.g:92:4: action_expr SEPR action_expr_list
{
- pushFollow(FOLLOW_action_expr_in_action_expr_list337);
- action_expr24=action_expr();
+ pushFollow(FOLLOW_action_expr_in_action_expr_list487);
+ action_expr36=action_expr();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) stream_action_expr.add(action_expr24.getTree());
- SEPR25=(Token)input.LT(1);
- match(input,SEPR,FOLLOW_SEPR_in_action_expr_list339); if (failed) return retval;
- if ( backtracking==0 ) stream_SEPR.add(SEPR25);
+ if ( backtracking==0 ) stream_action_expr.add(action_expr36.getTree());
+ SEPR37=(Token)input.LT(1);
+ match(input,SEPR,FOLLOW_SEPR_in_action_expr_list489); if (failed) return retval;
+ if ( backtracking==0 ) stream_SEPR.add(SEPR37);
- pushFollow(FOLLOW_action_expr_list_in_action_expr_list341);
- action_expr_list26=action_expr_list();
+ pushFollow(FOLLOW_action_expr_list_in_action_expr_list491);
+ action_expr_list38=action_expr_list();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) stream_action_expr_list.add(action_expr_list26.getTree());
+ if ( backtracking==0 ) stream_action_expr_list.add(action_expr_list38.getTree());
// AST REWRITE
- // elements: action_expr_list, action_expr, SEPR
+ // elements: action_expr, action_expr_list, SEPR
// token labels:
// rule labels: retval
// token list labels:
@@ -1213,9 +1653,9 @@
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
root_0 = (Object)adaptor.nil();
- // 77:38: -> ^( SEPR action_expr action_expr_list )
+ // 92:38: -> ^( SEPR action_expr action_expr_list )
{
- // dd/grammar/ECAGrammar.g:77:41: ^( SEPR action_expr action_expr_list )
+ // dd/grammar/ECAGrammar.g:92:41: ^( SEPR action_expr action_expr_list )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_SEPR.next(), root_1);
@@ -1233,15 +1673,15 @@
}
break;
case 2 :
- // dd/grammar/ECAGrammar.g:78:4: action_expr
+ // dd/grammar/ECAGrammar.g:93:4: action_expr
{
root_0 = (Object)adaptor.nil();
- pushFollow(FOLLOW_action_expr_in_action_expr_list356);
- action_expr27=action_expr();
+ pushFollow(FOLLOW_action_expr_in_action_expr_list506);
+ action_expr39=action_expr();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) adaptor.addChild(root_0, action_expr27.getTree());
+ if ( backtracking==0 ) adaptor.addChild(root_0, action_expr39.getTree());
}
break;
@@ -1270,28 +1710,28 @@
};
// $ANTLR start action_expr
- // dd/grammar/ECAGrammar.g:81:1: action_expr : expr ;
+ // dd/grammar/ECAGrammar.g:96:1: action_expr : expr ;
public final action_expr_return action_expr() throws RecognitionException {
action_expr_return retval = new action_expr_return();
retval.start = input.LT(1);
Object root_0 = null;
- expr_return expr28 = null;
+ expr_return expr40 = null;
try {
- // dd/grammar/ECAGrammar.g:81:13: ( expr )
- // dd/grammar/ECAGrammar.g:81:15: expr
+ // dd/grammar/ECAGrammar.g:96:13: ( expr )
+ // dd/grammar/ECAGrammar.g:96:15: expr
{
root_0 = (Object)adaptor.nil();
- pushFollow(FOLLOW_expr_in_action_expr366);
- expr28=expr();
+ pushFollow(FOLLOW_expr_in_action_expr516);
+ expr40=expr();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) adaptor.addChild(root_0, expr28.getTree());
+ if ( backtracking==0 ) adaptor.addChild(root_0, expr40.getTree());
}
@@ -1318,36 +1758,36 @@
};
// $ANTLR start expr
- // dd/grammar/ECAGrammar.g:84:1: expr : ( simple_expr infix_oper expr -> ^( BINOP infix_oper simple_expr expr ) | simple_expr | unary_oper expr -> ^( UNOP unary_oper expr ) | cond= simple_expr TERN_IF iftrue= expr COLON iffalse= expr -> ^( TERNOP $cond $iftrue $iffalse) );
+ // dd/grammar/ECAGrammar.g:99:1: expr : ( simple_expr infix_oper expr -> ^( BINOP infix_oper simple_expr expr ) | simple_expr | unary_oper expr -> ^( UNOP unary_oper expr ) | cond= simple_expr TERN_IF iftrue= expr COLON iffalse= expr -> ^( TERNOP $cond $iftrue $iffalse) );
public final expr_return expr() throws RecognitionException {
expr_return retval = new expr_return();
retval.start = input.LT(1);
Object root_0 = null;
- Token TERN_IF35=null;
- Token COLON36=null;
+ Token TERN_IF47=null;
+ Token COLON48=null;
simple_expr_return cond = null;
expr_return iftrue = null;
expr_return iffalse = null;
- simple_expr_return simple_expr29 = null;
+ simple_expr_return simple_expr41 = null;
- infix_oper_return infix_oper30 = null;
+ infix_oper_return infix_oper42 = null;
- expr_return expr31 = null;
+ expr_return expr43 = null;
- simple_expr_return simple_expr32 = null;
+ simple_expr_return simple_expr44 = null;
- unary_oper_return unary_oper33 = null;
+ unary_oper_return unary_oper45 = null;
- expr_return expr34 = null;
+ expr_return expr46 = null;
- Object TERN_IF35_tree=null;
- Object COLON36_tree=null;
+ Object TERN_IF47_tree=null;
+ Object COLON48_tree=null;
RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON");
RewriteRuleTokenStream stream_TERN_IF=new RewriteRuleTokenStream(adaptor,"token TERN_IF");
RewriteRuleSubtreeStream stream_unary_oper=new RewriteRuleSubtreeStream(adaptor,"rule unary_oper");
@@ -1355,23 +1795,12 @@
RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr");
RewriteRuleSubtreeStream stream_simple_expr=new RewriteRuleSubtreeStream(adaptor,"rule simple_expr");
try {
- // dd/grammar/ECAGrammar.g:84:6: ( simple_expr infix_oper expr -> ^( BINOP infix_oper simple_expr expr ) | simple_expr | unary_oper expr -> ^( UNOP unary_oper expr ) | cond= simple_expr TERN_IF iftrue= expr COLON iffalse= expr -> ^( TERNOP $cond $iftrue $iffalse) )
- int alt4=4;
+ // dd/grammar/ECAGrammar.g:99:6: ( simple_expr infix_oper expr -> ^( BINOP infix_oper simple_expr expr ) | simple_expr | unary_oper expr -> ^( UNOP unary_oper expr ) | cond= simple_expr TERN_IF iftrue= expr COLON iffalse= expr -> ^( TERNOP $cond $iftrue $iffalse) )
+ int alt6=4;
switch ( input.LA(1) ) {
case DOLLARSYM:
{
switch ( input.LA(2) ) {
- case EOF:
- case IF:
- case DO:
- case RPAREN:
- case RSQUARE:
- case SEPR:
- case COLON:
- {
- alt4=2;
- }
- break;
case OR:
case AND:
case EQ:
@@ -1388,18 +1817,30 @@
case PLUS:
case MINUS:
{
- alt4=1;
+ alt6=1;
}
break;
case TERN_IF:
{
- alt4=4;
+ alt6=4;
}
break;
+ case EOF:
+ case IF:
+ case DO:
+ case ENDRULE:
+ case RPAREN:
+ case RSQUARE:
+ case SEPR:
+ case COLON:
+ {
+ alt6=2;
+ }
+ break;
default:
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("84:1: expr : ( simple_expr infix_oper expr -> ^( BINOP infix_oper simple_expr expr ) | simple_expr | unary_oper expr -> ^( UNOP unary_oper expr ) | cond= simple_expr TERN_IF iftrue= expr COLON iffalse= expr -> ^( TERNOP $cond $iftrue $iffalse) );", 4, 1, input);
+ new NoViableAltException("99:1: expr : ( simple_expr infix_oper expr -> ^( BINOP infix_oper simple_expr expr ) | simple_expr | unary_oper expr -> ^( UNOP unary_oper expr ) | cond= simple_expr TERN_IF iftrue= expr COLON iffalse= expr -> ^( TERNOP $cond $iftrue $iffalse) );", 6, 1, input);
throw nvae;
}
@@ -1411,62 +1852,63 @@
switch ( input.LA(2) ) {
case LPAREN:
{
- int LA4_10 = input.LA(3);
+ int LA6_10 = input.LA(3);
- if ( (synpred4()) ) {
- alt4=1;
+ if ( (synpred7()) ) {
+ alt6=1;
}
- else if ( (synpred5()) ) {
- alt4=2;
+ else if ( (synpred8()) ) {
+ alt6=2;
}
else if ( (true) ) {
- alt4=4;
+ alt6=4;
}
else {
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("84:1: expr : ( simple_expr infix_oper expr -> ^( BINOP infix_oper simple_expr expr ) | simple_expr | unary_oper expr -> ^( UNOP unary_oper expr ) | cond= simple_expr TERN_IF iftrue= expr COLON iffalse= expr -> ^( TERNOP $cond $iftrue $iffalse) );", 4, 10, input);
+ new NoViableAltException("99:1: expr : ( simple_expr infix_oper expr -> ^( BINOP infix_oper simple_expr expr ) | simple_expr | unary_oper expr -> ^( UNOP unary_oper expr ) | cond= simple_expr TERN_IF iftrue= expr COLON iffalse= expr -> ^( TERNOP $cond $iftrue $iffalse) );", 6, 10, input);
throw nvae;
}
}
break;
+ case TERN_IF:
+ {
+ alt6=4;
+ }
+ break;
case LSQUARE:
{
- int LA4_11 = input.LA(3);
+ int LA6_11 = input.LA(3);
- if ( (synpred4()) ) {
- alt4=1;
+ if ( (synpred7()) ) {
+ alt6=1;
}
- else if ( (synpred5()) ) {
- alt4=2;
+ else if ( (synpred8()) ) {
+ alt6=2;
}
else if ( (true) ) {
- alt4=4;
+ alt6=4;
}
else {
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("84:1: expr : ( simple_expr infix_oper expr -> ^( BINOP infix_oper simple_expr expr ) | simple_expr | unary_oper expr -> ^( UNOP unary_oper expr ) | cond= simple_expr TERN_IF iftrue= expr COLON iffalse= expr -> ^( TERNOP $cond $iftrue $iffalse) );", 4, 11, input);
+ new NoViableAltException("99:1: expr : ( simple_expr infix_oper expr -> ^( BINOP infix_oper simple_expr expr ) | simple_expr | unary_oper expr -> ^( UNOP unary_oper expr ) | cond= simple_expr TERN_IF iftrue= expr COLON iffalse= expr -> ^( TERNOP $cond $iftrue $iffalse) );", 6, 11, input);
throw nvae;
}
}
break;
- case TERN_IF:
- {
- alt4=4;
- }
- break;
case EOF:
case IF:
case DO:
+ case ENDRULE:
case RPAREN:
case RSQUARE:
case SEPR:
case COLON:
{
- alt4=2;
+ alt6=2;
}
break;
case OR:
@@ -1485,13 +1927,13 @@
case PLUS:
case MINUS:
{
- alt4=1;
+ alt6=1;
}
break;
default:
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("84:1: expr : ( simple_expr infix_oper expr -> ^( BINOP infix_oper simple_expr expr ) | simple_expr | unary_oper expr -> ^( UNOP unary_oper expr ) | cond= simple_expr TERN_IF iftrue= expr COLON iffalse= expr -> ^( TERNOP $cond $iftrue $iffalse) );", 4, 2, input);
+ new NoViableAltException("99:1: expr : ( simple_expr infix_oper expr -> ^( BINOP infix_oper simple_expr expr ) | simple_expr | unary_oper expr -> ^( UNOP unary_oper expr ) | cond= simple_expr TERN_IF iftrue= expr COLON iffalse= expr -> ^( TERNOP $cond $iftrue $iffalse) );", 6, 2, input);
throw nvae;
}
@@ -1501,22 +1943,6 @@
case NUMBER:
{
switch ( input.LA(2) ) {
- case TERN_IF:
- {
- alt4=4;
- }
- break;
- case EOF:
- case IF:
- case DO:
- case RPAREN:
- case RSQUARE:
- case SEPR:
- case COLON:
- {
- alt4=2;
- }
- break;
case OR:
case AND:
case EQ:
@@ -1533,13 +1959,30 @@
case PLUS:
case MINUS:
{
- alt4=1;
+ alt6=1;
}
break;
+ case TERN_IF:
+ {
+ alt6=4;
+ }
+ break;
+ case EOF:
+ case IF:
+ case DO:
+ case ENDRULE:
+ case RPAREN:
+ case RSQUARE:
+ case SEPR:
+ case COLON:
+ {
+ alt6=2;
+ }
+ break;
default:
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("84:1: expr : ( simple_expr infix_oper expr -> ^( BINOP infix_oper simple_expr expr ) | simple_expr | unary_oper expr -> ^( UNOP unary_oper expr ) | cond= simple_expr TERN_IF iftrue= expr COLON iffalse= expr -> ^( TERNOP $cond $iftrue $iffalse) );", 4, 3, input);
+ new NoViableAltException("99:1: expr : ( simple_expr infix_oper expr -> ^( BINOP infix_oper simple_expr expr ) | simple_expr | unary_oper expr -> ^( UNOP unary_oper expr ) | cond= simple_expr TERN_IF iftrue= expr COLON iffalse= expr -> ^( TERNOP $cond $iftrue $iffalse) );", 6, 3, input);
throw nvae;
}
@@ -1549,6 +1992,23 @@
case STRING:
{
switch ( input.LA(2) ) {
+ case EOF:
+ case IF:
+ case DO:
+ case ENDRULE:
+ case RPAREN:
+ case RSQUARE:
+ case SEPR:
+ case COLON:
+ {
+ alt6=2;
+ }
+ break;
+ case TERN_IF:
+ {
+ alt6=4;
+ }
+ break;
case OR:
case AND:
case EQ:
@@ -1565,29 +2025,13 @@
case PLUS:
case MINUS:
{
- alt4=1;
+ alt6=1;
}
break;
- case EOF:
- case IF:
- case DO:
- case RPAREN:
- case RSQUARE:
- case SEPR:
- case COLON:
- {
- alt4=2;
- }
- break;
- case TERN_IF:
- {
- alt4=4;
- }
- break;
default:
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("84:1: expr : ( simple_expr infix_oper expr -> ^( BINOP infix_oper simple_expr expr ) | simple_expr | unary_oper expr -> ^( UNOP unary_oper expr ) | cond= simple_expr TERN_IF iftrue= expr COLON iffalse= expr -> ^( TERNOP $cond $iftrue $iffalse) );", 4, 4, input);
+ new NoViableAltException("99:1: expr : ( simple_expr infix_oper expr -> ^( BINOP infix_oper simple_expr expr ) | simple_expr | unary_oper expr -> ^( UNOP unary_oper expr ) | cond= simple_expr TERN_IF iftrue= expr COLON iffalse= expr -> ^( TERNOP $cond $iftrue $iffalse) );", 6, 4, input);
throw nvae;
}
@@ -1596,21 +2040,21 @@
break;
case LPAREN:
{
- int LA4_5 = input.LA(2);
+ int LA6_5 = input.LA(2);
- if ( (synpred4()) ) {
- alt4=1;
+ if ( (synpred7()) ) {
+ alt6=1;
}
- else if ( (synpred5()) ) {
- alt4=2;
+ else if ( (synpred8()) ) {
+ alt6=2;
}
else if ( (true) ) {
- alt4=4;
+ alt6=4;
}
else {
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("84:1: expr : ( simple_expr infix_oper expr -> ^( BINOP infix_oper simple_expr expr ) | simple_expr | unary_oper expr -> ^( UNOP unary_oper expr ) | cond= simple_expr TERN_IF iftrue= expr COLON iffalse= expr -> ^( TERNOP $cond $iftrue $iffalse) );", 4, 5, input);
+ new NoViableAltException("99:1: expr : ( simple_expr infix_oper expr -> ^( BINOP infix_oper simple_expr expr ) | simple_expr | unary_oper expr -> ^( UNOP unary_oper expr ) | cond= simple_expr TERN_IF iftrue= expr COLON iffalse= expr -> ^( TERNOP $cond $iftrue $iffalse) );", 6, 5, input);
throw nvae;
}
@@ -1619,39 +2063,39 @@
case NOT:
case TWIDDLE:
{
- alt4=3;
+ alt6=3;
}
break;
default:
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("84:1: expr : ( simple_expr infix_oper expr -> ^( BINOP infix_oper simple_expr expr ) | simple_expr | unary_oper expr -> ^( UNOP unary_oper expr ) | cond= simple_expr TERN_IF iftrue= expr COLON iffalse= expr -> ^( TERNOP $cond $iftrue $iffalse) );", 4, 0, input);
+ new NoViableAltException("99:1: expr : ( simple_expr infix_oper expr -> ^( BINOP infix_oper simple_expr expr ) | simple_expr | unary_oper expr -> ^( UNOP unary_oper expr ) | cond= simple_expr TERN_IF iftrue= expr COLON iffalse= expr -> ^( TERNOP $cond $iftrue $iffalse) );", 6, 0, input);
throw nvae;
}
- switch (alt4) {
+ switch (alt6) {
case 1 :
- // dd/grammar/ECAGrammar.g:84:8: simple_expr infix_oper expr
+ // dd/grammar/ECAGrammar.g:99:8: simple_expr infix_oper expr
{
- pushFollow(FOLLOW_simple_expr_in_expr376);
- simple_expr29=simple_expr();
+ pushFollow(FOLLOW_simple_expr_in_expr526);
+ simple_expr41=simple_expr();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) stream_simple_expr.add(simple_expr29.getTree());
- pushFollow(FOLLOW_infix_oper_in_expr378);
- infix_oper30=infix_oper();
+ if ( backtracking==0 ) stream_simple_expr.add(simple_expr41.getTree());
+ pushFollow(FOLLOW_infix_oper_in_expr528);
+ infix_oper42=infix_oper();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) stream_infix_oper.add(infix_oper30.getTree());
- pushFollow(FOLLOW_expr_in_expr380);
- expr31=expr();
+ if ( backtracking==0 ) stream_infix_oper.add(infix_oper42.getTree());
+ pushFollow(FOLLOW_expr_in_expr530);
+ expr43=expr();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) stream_expr.add(expr31.getTree());
+ if ( backtracking==0 ) stream_expr.add(expr43.getTree());
// AST REWRITE
- // elements: infix_oper, simple_expr, expr
+ // elements: infix_oper, expr, simple_expr
// token labels:
// rule labels: retval
// token list labels:
@@ -1661,9 +2105,9 @@
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
root_0 = (Object)adaptor.nil();
- // 84:37: -> ^( BINOP infix_oper simple_expr expr )
+ // 99:37: -> ^( BINOP infix_oper simple_expr expr )
{
- // dd/grammar/ECAGrammar.g:84:40: ^( BINOP infix_oper simple_expr expr )
+ // dd/grammar/ECAGrammar.g:99:40: ^( BINOP infix_oper simple_expr expr )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(adaptor.create(BINOP, "BINOP"), root_1);
@@ -1682,31 +2126,31 @@
}
break;
case 2 :
- // dd/grammar/ECAGrammar.g:85:4: simple_expr
+ // dd/grammar/ECAGrammar.g:100:4: simple_expr
{
root_0 = (Object)adaptor.nil();
- pushFollow(FOLLOW_simple_expr_in_expr398);
- simple_expr32=simple_expr();
+ pushFollow(FOLLOW_simple_expr_in_expr548);
+ simple_expr44=simple_expr();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) adaptor.addChild(root_0, simple_expr32.getTree());
+ if ( backtracking==0 ) adaptor.addChild(root_0, simple_expr44.getTree());
}
break;
case 3 :
- // dd/grammar/ECAGrammar.g:86:4: unary_oper expr
+ // dd/grammar/ECAGrammar.g:101:4: unary_oper expr
{
- pushFollow(FOLLOW_unary_oper_in_expr403);
- unary_oper33=unary_oper();
+ pushFollow(FOLLOW_unary_oper_in_expr553);
+ unary_oper45=unary_oper();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) stream_unary_oper.add(unary_oper33.getTree());
- pushFollow(FOLLOW_expr_in_expr405);
- expr34=expr();
+ if ( backtracking==0 ) stream_unary_oper.add(unary_oper45.getTree());
+ pushFollow(FOLLOW_expr_in_expr555);
+ expr46=expr();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) stream_expr.add(expr34.getTree());
+ if ( backtracking==0 ) stream_expr.add(expr46.getTree());
// AST REWRITE
// elements: expr, unary_oper
@@ -1719,9 +2163,9 @@
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
root_0 = (Object)adaptor.nil();
- // 86:22: -> ^( UNOP unary_oper expr )
+ // 101:22: -> ^( UNOP unary_oper expr )
{
- // dd/grammar/ECAGrammar.g:86:25: ^( UNOP unary_oper expr )
+ // dd/grammar/ECAGrammar.g:101:25: ^( UNOP unary_oper expr )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(adaptor.create(UNOP, "UNOP"), root_1);
@@ -1739,49 +2183,49 @@
}
break;
case 4 :
- // dd/grammar/ECAGrammar.g:87:4: cond= simple_expr TERN_IF iftrue= expr COLON iffalse= expr
+ // dd/grammar/ECAGrammar.g:102:4: cond= simple_expr TERN_IF iftrue= expr COLON iffalse= expr
{
- pushFollow(FOLLOW_simple_expr_in_expr424);
+ pushFollow(FOLLOW_simple_expr_in_expr574);
cond=simple_expr();
_fsp--;
if (failed) return retval;
if ( backtracking==0 ) stream_simple_expr.add(cond.getTree());
- TERN_IF35=(Token)input.LT(1);
- match(input,TERN_IF,FOLLOW_TERN_IF_in_expr426); if (failed) return retval;
- if ( backtracking==0 ) stream_TERN_IF.add(TERN_IF35);
+ TERN_IF47=(Token)input.LT(1);
+ match(input,TERN_IF,FOLLOW_TERN_IF_in_expr576); if (failed) return retval;
+ if ( backtracking==0 ) stream_TERN_IF.add(TERN_IF47);
- pushFollow(FOLLOW_expr_in_expr430);
+ pushFollow(FOLLOW_expr_in_expr580);
iftrue=expr();
_fsp--;
if (failed) return retval;
if ( backtracking==0 ) stream_expr.add(iftrue.getTree());
- COLON36=(Token)input.LT(1);
- match(input,COLON,FOLLOW_COLON_in_expr432); if (failed) return retval;
- if ( backtracking==0 ) stream_COLON.add(COLON36);
+ COLON48=(Token)input.LT(1);
+ match(input,COLON,FOLLOW_COLON_in_expr582); if (failed) return retval;
+ if ( backtracking==0 ) stream_COLON.add(COLON48);
- pushFollow(FOLLOW_expr_in_expr436);
+ pushFollow(FOLLOW_expr_in_expr586);
iffalse=expr();
_fsp--;
if (failed) return retval;
if ( backtracking==0 ) stream_expr.add(iffalse.getTree());
// AST REWRITE
- // elements: iftrue, iffalse, cond
+ // elements: iftrue, cond, iffalse
// token labels:
- // rule labels: iftrue, cond, iffalse, retval
+ // rule labels: iftrue, iffalse, cond, retval
// token list labels:
// rule list labels:
if ( backtracking==0 ) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_iftrue=new RewriteRuleSubtreeStream(adaptor,"token iftrue",iftrue!=null?iftrue.tree:null);
+ RewriteRuleSubtreeStream stream_iffalse=new RewriteRuleSubtreeStream(adaptor,"token iffalse",iffalse!=null?iffalse.tree:null);
RewriteRuleSubtreeStream stream_cond=new RewriteRuleSubtreeStream(adaptor,"token cond",cond!=null?cond.tree:null);
- RewriteRuleSubtreeStream stream_iffalse=new RewriteRuleSubtreeStream(adaptor,"token iffalse",iffalse!=null?iffalse.tree:null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
root_0 = (Object)adaptor.nil();
- // 87:60: -> ^( TERNOP $cond $iftrue $iffalse)
+ // 102:60: -> ^( TERNOP $cond $iftrue $iffalse)
{
- // dd/grammar/ECAGrammar.g:87:63: ^( TERNOP $cond $iftrue $iffalse)
+ // dd/grammar/ECAGrammar.g:102:63: ^( TERNOP $cond $iftrue $iffalse)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(adaptor.create(TERNOP, "TERNOP"), root_1);
@@ -1824,7 +2268,7 @@
};
// $ANTLR start simple_expr
- // dd/grammar/ECAGrammar.g:90:1: simple_expr : (v= DOLLARSYM | v= SYMBOL idx= array_idx -> ^( ARRAY $v $idx) | v= SYMBOL LPAREN RPAREN -> ^( METH $v) | v= SYMBOL | v= SYMBOL LPAREN args= expr_list RPAREN -> ^( METH $v $args) | NUMBER | STRING | LPAREN expr RPAREN -> ^( expr ) );
+ // dd/grammar/ECAGrammar.g:105:1: simple_expr : (v= DOLLARSYM | v= SYMBOL idx= array_idx -> ^( ARRAY $v $idx) | v= SYMBOL LPAREN RPAREN -> ^( METH $v) | v= SYMBOL | v= SYMBOL LPAREN args= expr_list RPAREN -> ^( METH $v $args) | NUMBER | STRING | LPAREN expr RPAREN -> ^( expr ) );
public final simple_expr_return simple_expr() throws RecognitionException {
simple_expr_return retval = new simple_expr_return();
retval.start = input.LT(1);
@@ -1832,30 +2276,30 @@
Object root_0 = null;
Token v=null;
- Token LPAREN37=null;
- Token RPAREN38=null;
- Token LPAREN39=null;
- Token RPAREN40=null;
- Token NUMBER41=null;
- Token STRING42=null;
- Token LPAREN43=null;
- Token RPAREN45=null;
+ Token LPAREN49=null;
+ Token RPAREN50=null;
+ Token LPAREN51=null;
+ Token RPAREN52=null;
+ Token NUMBER53=null;
+ Token STRING54=null;
+ Token LPAREN55=null;
+ Token RPAREN57=null;
array_idx_return idx = null;
expr_list_return args = null;
- expr_return expr44 = null;
+ expr_return expr56 = null;
Object v_tree=null;
- Object LPAREN37_tree=null;
- Object RPAREN38_tree=null;
- Object LPAREN39_tree=null;
- Object RPAREN40_tree=null;
- Object NUMBER41_tree=null;
- Object STRING42_tree=null;
- Object LPAREN43_tree=null;
- Object RPAREN45_tree=null;
+ Object LPAREN49_tree=null;
+ Object RPAREN50_tree=null;
+ Object LPAREN51_tree=null;
+ Object RPAREN52_tree=null;
+ Object NUMBER53_tree=null;
+ Object STRING54_tree=null;
+ Object LPAREN55_tree=null;
+ Object RPAREN57_tree=null;
RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
RewriteRuleTokenStream stream_SYMBOL=new RewriteRuleTokenStream(adaptor,"token SYMBOL");
@@ -1863,12 +2307,12 @@
RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr");
RewriteRuleSubtreeStream stream_array_idx=new RewriteRuleSubtreeStream(adaptor,"rule array_idx");
try {
- // dd/grammar/ECAGrammar.g:90:13: (v= DOLLARSYM | v= SYMBOL idx= array_idx -> ^( ARRAY $v $idx) | v= SYMBOL LPAREN RPAREN -> ^( METH $v) | v= SYMBOL | v= SYMBOL LPAREN args= expr_list RPAREN -> ^( METH $v $args) | NUMBER | STRING | LPAREN expr RPAREN -> ^( expr ) )
- int alt5=8;
+ // dd/grammar/ECAGrammar.g:105:13: (v= DOLLARSYM | v= SYMBOL idx= array_idx -> ^( ARRAY $v $idx) | v= SYMBOL LPAREN RPAREN -> ^( METH $v) | v= SYMBOL | v= SYMBOL LPAREN args= expr_list RPAREN -> ^( METH $v $args) | NUMBER | STRING | LPAREN expr RPAREN -> ^( expr ) )
+ int alt7=8;
switch ( input.LA(1) ) {
case DOLLARSYM:
{
- alt5=1;
+ alt7=1;
}
break;
case SYMBOL:
@@ -1876,18 +2320,18 @@
switch ( input.LA(2) ) {
case LPAREN:
{
- int LA5_6 = input.LA(3);
+ int LA7_6 = input.LA(3);
- if ( (LA5_6==RPAREN) ) {
- alt5=3;
+ if ( (LA7_6==RPAREN) ) {
+ alt7=3;
}
- else if ( (LA5_6==NUMBER||LA5_6==LPAREN||LA5_6==NOT||LA5_6==TWIDDLE||LA5_6==STRING||LA5_6==SYMBOL||LA5_6==DOLLARSYM) ) {
- alt5=5;
+ else if ( (LA7_6==NUMBER||LA7_6==LPAREN||LA7_6==NOT||LA7_6==TWIDDLE||LA7_6==STRING||LA7_6==SYMBOL||LA7_6==DOLLARSYM) ) {
+ alt7=5;
}
else {
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("90:1: simple_expr : (v= DOLLARSYM | v= SYMBOL idx= array_idx -> ^( ARRAY $v $idx) | v= SYMBOL LPAREN RPAREN -> ^( METH $v) | v= SYMBOL | v= SYMBOL LPAREN args= expr_list RPAREN -> ^( METH $v $args) | NUMBER | STRING | LPAREN expr RPAREN -> ^( expr ) );", 5, 6, input);
+ new NoViableAltException("105:1: simple_expr : (v= DOLLARSYM | v= SYMBOL idx= array_idx -> ^( ARRAY $v $idx) | v= SYMBOL LPAREN RPAREN -> ^( METH $v) | v= SYMBOL | v= SYMBOL LPAREN args= expr_list RPAREN -> ^( METH $v $args) | NUMBER | STRING | LPAREN expr RPAREN -> ^( expr ) );", 7, 6, input);
throw nvae;
}
@@ -1895,12 +2339,13 @@
break;
case LSQUARE:
{
- alt5=2;
+ alt7=2;
}
break;
case EOF:
case IF:
case DO:
+ case ENDRULE:
case RPAREN:
case RSQUARE:
case SEPR:
@@ -1922,13 +2367,13 @@
case TERN_IF:
case COLON:
{
- alt5=4;
+ alt7=4;
}
break;
default:
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("90:1: simple_expr : (v= DOLLARSYM | v= SYMBOL idx= array_idx -> ^( ARRAY $v $idx) | v= SYMBOL LPAREN RPAREN -> ^( METH $v) | v= SYMBOL | v= SYMBOL LPAREN args= expr_list RPAREN -> ^( METH $v $args) | NUMBER | STRING | LPAREN expr RPAREN -> ^( expr ) );", 5, 2, input);
+ new NoViableAltException("105:1: simple_expr : (v= DOLLARSYM | v= SYMBOL idx= array_idx -> ^( ARRAY $v $idx) | v= SYMBOL LPAREN RPAREN -> ^( METH $v) | v= SYMBOL | v= SYMBOL LPAREN args= expr_list RPAREN -> ^( METH $v $args) | NUMBER | STRING | LPAREN expr RPAREN -> ^( expr ) );", 7, 2, input);
throw nvae;
}
@@ -1937,35 +2382,35 @@
break;
case NUMBER:
{
- alt5=6;
+ alt7=6;
}
break;
case STRING:
{
- alt5=7;
+ alt7=7;
}
break;
case LPAREN:
{
- alt5=8;
+ alt7=8;
}
break;
default:
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("90:1: simple_expr : (v= DOLLARSYM | v= SYMBOL idx= array_idx -> ^( ARRAY $v $idx) | v= SYMBOL LPAREN RPAREN -> ^( METH $v) | v= SYMBOL | v= SYMBOL LPAREN args= expr_list RPAREN -> ^( METH $v $args) | NUMBER | STRING | LPAREN expr RPAREN -> ^( expr ) );", 5, 0, input);
+ new NoViableAltException("105:1: simple_expr : (v= DOLLARSYM | v= SYMBOL idx= array_idx -> ^( ARRAY $v $idx) | v= SYMBOL LPAREN RPAREN -> ^( METH $v) | v= SYMBOL | v= SYMBOL LPAREN args= expr_list RPAREN -> ^( METH $v $args) | NUMBER | STRING | LPAREN expr RPAREN -> ^( expr ) );", 7, 0, input);
throw nvae;
}
- switch (alt5) {
+ switch (alt7) {
case 1 :
- // dd/grammar/ECAGrammar.g:90:15: v= DOLLARSYM
+ // dd/grammar/ECAGrammar.g:105:15: v= DOLLARSYM
{
root_0 = (Object)adaptor.nil();
v=(Token)input.LT(1);
- match(input,DOLLARSYM,FOLLOW_DOLLARSYM_in_simple_expr463); if (failed) return retval;
+ match(input,DOLLARSYM,FOLLOW_DOLLARSYM_in_simple_expr613); if (failed) return retval;
if ( backtracking==0 ) {
v_tree = (Object)adaptor.create(v);
adaptor.addChild(root_0, v_tree);
@@ -1974,20 +2419,20 @@
}
break;
case 2 :
- // dd/grammar/ECAGrammar.g:91:4: v= SYMBOL idx= array_idx
+ // dd/grammar/ECAGrammar.g:106:4: v= SYMBOL idx= array_idx
{
v=(Token)input.LT(1);
- match(input,SYMBOL,FOLLOW_SYMBOL_in_simple_expr470); if (failed) return retval;
+ match(input,SYMBOL,FOLLOW_SYMBOL_in_simple_expr620); if (failed) return retval;
if ( backtracking==0 ) stream_SYMBOL.add(v);
- pushFollow(FOLLOW_array_idx_in_simple_expr474);
+ pushFollow(FOLLOW_array_idx_in_simple_expr624);
idx=array_idx();
_fsp--;
if (failed) return retval;
if ( backtracking==0 ) stream_array_idx.add(idx.getTree());
// AST REWRITE
- // elements: v, idx
+ // elements: idx, v
// token labels: v
// rule labels: idx, retval
// token list labels:
@@ -1999,9 +2444,9 @@
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
root_0 = (Object)adaptor.nil();
- // 91:29: -> ^( ARRAY $v $idx)
+ // 106:29: -> ^( ARRAY $v $idx)
{
- // dd/grammar/ECAGrammar.g:91:32: ^( ARRAY $v $idx)
+ // dd/grammar/ECAGrammar.g:106:32: ^( ARRAY $v $idx)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(adaptor.create(ARRAY, "ARRAY"), root_1);
@@ -2019,19 +2464,19 @@
}
break;
case 3 :
- // dd/grammar/ECAGrammar.g:92:4: v= SYMBOL LPAREN RPAREN
+ // dd/grammar/ECAGrammar.g:107:4: v= SYMBOL LPAREN RPAREN
{
v=(Token)input.LT(1);
- match(input,SYMBOL,FOLLOW_SYMBOL_in_simple_expr495); if (failed) return retval;
+ match(input,SYMBOL,FOLLOW_SYMBOL_in_simple_expr645); if (failed) return retval;
if ( backtracking==0 ) stream_SYMBOL.add(v);
- LPAREN37=(Token)input.LT(1);
- match(input,LPAREN,FOLLOW_LPAREN_in_simple_expr497); if (failed) return retval;
- if ( backtracking==0 ) stream_LPAREN.add(LPAREN37);
+ LPAREN49=(Token)input.LT(1);
+ match(input,LPAREN,FOLLOW_LPAREN_in_simple_expr647); if (failed) return retval;
+ if ( backtracking==0 ) stream_LPAREN.add(LPAREN49);
- RPAREN38=(Token)input.LT(1);
- match(input,RPAREN,FOLLOW_RPAREN_in_simple_expr499); if (failed) return retval;
- if ( backtracking==0 ) stream_RPAREN.add(RPAREN38);
+ RPAREN50=(Token)input.LT(1);
+ match(input,RPAREN,FOLLOW_RPAREN_in_simple_expr649); if (failed) return retval;
+ if ( backtracking==0 ) stream_RPAREN.add(RPAREN50);
// AST REWRITE
@@ -2046,9 +2491,9 @@
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
root_0 = (Object)adaptor.nil();
- // 92:29: -> ^( METH $v)
+ // 107:29: -> ^( METH $v)
{
- // dd/grammar/ECAGrammar.g:92:32: ^( METH $v)
+ // dd/grammar/ECAGrammar.g:107:32: ^( METH $v)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(adaptor.create(METH, "METH"), root_1);
@@ -2065,12 +2510,12 @@
}
break;
case 4 :
- // dd/grammar/ECAGrammar.g:93:4: v= SYMBOL
+ // dd/grammar/ECAGrammar.g:108:4: v= SYMBOL
{
root_0 = (Object)adaptor.nil();
v=(Token)input.LT(1);
- match(input,SYMBOL,FOLLOW_SYMBOL_in_simple_expr517); if (failed) return retval;
+ match(input,SYMBOL,FOLLOW_SYMBOL_in_simple_expr667); if (failed) return retval;
if ( backtracking==0 ) {
v_tree = (Object)adaptor.create(v);
adaptor.addChild(root_0, v_tree);
@@ -2079,28 +2524,28 @@
}
break;
case 5 :
- // dd/grammar/ECAGrammar.g:94:4: v= SYMBOL LPAREN args= expr_list RPAREN
+ // dd/grammar/ECAGrammar.g:109:4: v= SYMBOL LPAREN args= expr_list RPAREN
{
v=(Token)input.LT(1);
- match(input,SYMBOL,FOLLOW_SYMBOL_in_simple_expr524); if (failed) return retval;
+ match(input,SYMBOL,FOLLOW_SYMBOL_in_simple_expr674); if (failed) return retval;
if ( backtracking==0 ) stream_SYMBOL.add(v);
- LPAREN39=(Token)input.LT(1);
- match(input,LPAREN,FOLLOW_LPAREN_in_simple_expr526); if (failed) return retval;
- if ( backtracking==0 ) stream_LPAREN.add(LPAREN39);
+ LPAREN51=(Token)input.LT(1);
+ match(input,LPAREN,FOLLOW_LPAREN_in_simple_expr676); if (failed) return retval;
+ if ( backtracking==0 ) stream_LPAREN.add(LPAREN51);
- pushFollow(FOLLOW_expr_list_in_simple_expr530);
+ pushFollow(FOLLOW_expr_list_in_simple_expr680);
args=expr_list();
_fsp--;
if (failed) return retval;
if ( backtracking==0 ) stream_expr_list.add(args.getTree());
- RPAREN40=(Token)input.LT(1);
- match(input,RPAREN,FOLLOW_RPAREN_in_simple_expr532); if (failed) return retval;
- if ( backtracking==0 ) stream_RPAREN.add(RPAREN40);
+ RPAREN52=(Token)input.LT(1);
+ match(input,RPAREN,FOLLOW_RPAREN_in_simple_expr682); if (failed) return retval;
+ if ( backtracking==0 ) stream_RPAREN.add(RPAREN52);
// AST REWRITE
- // elements: args, v
+ // elements: v, args
// token labels: v
// rule labels: args, retval
// token list labels:
@@ -2112,9 +2557,9 @@
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
root_0 = (Object)adaptor.nil();
- // 94:43: -> ^( METH $v $args)
+ // 109:43: -> ^( METH $v $args)
{
- // dd/grammar/ECAGrammar.g:94:46: ^( METH $v $args)
+ // dd/grammar/ECAGrammar.g:109:46: ^( METH $v $args)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(adaptor.create(METH, "METH"), root_1);
@@ -2132,48 +2577,48 @@
}
break;
case 6 :
- // dd/grammar/ECAGrammar.g:95:4: NUMBER
+ // dd/grammar/ECAGrammar.g:110:4: NUMBER
{
root_0 = (Object)adaptor.nil();
- NUMBER41=(Token)input.LT(1);
- match(input,NUMBER,FOLLOW_NUMBER_in_simple_expr551); if (failed) return retval;
+ NUMBER53=(Token)input.LT(1);
+ match(input,NUMBER,FOLLOW_NUMBER_in_simple_expr701); if (failed) return retval;
if ( backtracking==0 ) {
- NUMBER41_tree = (Object)adaptor.create(NUMBER41);
- adaptor.addChild(root_0, NUMBER41_tree);
+ NUMBER53_tree = (Object)adaptor.create(NUMBER53);
+ adaptor.addChild(root_0, NUMBER53_tree);
}
}
break;
case 7 :
- // dd/grammar/ECAGrammar.g:96:4: STRING
+ // dd/grammar/ECAGrammar.g:111:4: STRING
{
root_0 = (Object)adaptor.nil();
- STRING42=(Token)input.LT(1);
- match(input,STRING,FOLLOW_STRING_in_simple_expr556); if (failed) return retval;
+ STRING54=(Token)input.LT(1);
+ match(input,STRING,FOLLOW_STRING_in_simple_expr706); if (failed) return retval;
if ( backtracking==0 ) {
- STRING42_tree = (Object)adaptor.create(STRING42);
- adaptor.addChild(root_0, STRING42_tree);
+ STRING54_tree = (Object)adaptor.create(STRING54);
+ adaptor.addChild(root_0, STRING54_tree);
}
}
break;
case 8 :
- // dd/grammar/ECAGrammar.g:97:4: LPAREN expr RPAREN
+ // dd/grammar/ECAGrammar.g:112:4: LPAREN expr RPAREN
{
- LPAREN43=(Token)input.LT(1);
- match(input,LPAREN,FOLLOW_LPAREN_in_simple_expr561); if (failed) return retval;
- if ( backtracking==0 ) stream_LPAREN.add(LPAREN43);
+ LPAREN55=(Token)input.LT(1);
+ match(input,LPAREN,FOLLOW_LPAREN_in_simple_expr711); if (failed) return retval;
+ if ( backtracking==0 ) stream_LPAREN.add(LPAREN55);
- pushFollow(FOLLOW_expr_in_simple_expr563);
- expr44=expr();
+ pushFollow(FOLLOW_expr_in_simple_expr713);
+ expr56=expr();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) stream_expr.add(expr44.getTree());
- RPAREN45=(Token)input.LT(1);
- match(input,RPAREN,FOLLOW_RPAREN_in_simple_expr565); if (failed) return retval;
- if ( backtracking==0 ) stream_RPAREN.add(RPAREN45);
+ if ( backtracking==0 ) stream_expr.add(expr56.getTree());
+ RPAREN57=(Token)input.LT(1);
+ match(input,RPAREN,FOLLOW_RPAREN_in_simple_expr715); if (failed) return retval;
+ if ( backtracking==0 ) stream_RPAREN.add(RPAREN57);
// AST REWRITE
@@ -2187,9 +2632,9 @@
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
root_0 = (Object)adaptor.nil();
- // 97:25: -> ^( expr )
+ // 112:25: -> ^( expr )
{
- // dd/grammar/ECAGrammar.g:97:28: ^( expr )
+ // dd/grammar/ECAGrammar.g:112:28: ^( expr )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_expr.nextNode(), root_1);
@@ -2228,43 +2673,43 @@
};
// $ANTLR start expr_list
- // dd/grammar/ECAGrammar.g:100:1: expr_list : ( expr SEPR expr_list -> ^( SEPR expr expr_list ) | expr );
+ // dd/grammar/ECAGrammar.g:115:1: expr_list : ( expr SEPR expr_list -> ^( SEPR expr expr_list ) | expr );
public final expr_list_return expr_list() throws RecognitionException {
expr_list_return retval = new expr_list_return();
retval.start = input.LT(1);
Object root_0 = null;
- Token SEPR47=null;
- expr_return expr46 = null;
+ Token SEPR59=null;
+ expr_return expr58 = null;
- expr_list_return expr_list48 = null;
+ expr_list_return expr_list60 = null;
- expr_return expr49 = null;
+ expr_return expr61 = null;
- Object SEPR47_tree=null;
+ Object SEPR59_tree=null;
RewriteRuleTokenStream stream_SEPR=new RewriteRuleTokenStream(adaptor,"token SEPR");
RewriteRuleSubtreeStream stream_expr_list=new RewriteRuleSubtreeStream(adaptor,"rule expr_list");
RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr");
try {
- // dd/grammar/ECAGrammar.g:101:2: ( expr SEPR expr_list -> ^( SEPR expr expr_list ) | expr )
- int alt6=2;
+ // dd/grammar/ECAGrammar.g:116:2: ( expr SEPR expr_list -> ^( SEPR expr expr_list ) | expr )
+ int alt8=2;
switch ( input.LA(1) ) {
case DOLLARSYM:
{
- int LA6_1 = input.LA(2);
+ int LA8_1 = input.LA(2);
- if ( (synpred14()) ) {
- alt6=1;
+ if ( (synpred17()) ) {
+ alt8=1;
}
else if ( (true) ) {
- alt6=2;
+ alt8=2;
}
else {
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("100:1: expr_list : ( expr SEPR expr_list -> ^( SEPR expr expr_list ) | expr );", 6, 1, input);
+ new NoViableAltException("115:1: expr_list : ( expr SEPR expr_list -> ^( SEPR expr expr_list ) | expr );", 8, 1, input);
throw nvae;
}
@@ -2272,18 +2717,18 @@
break;
case SYMBOL:
{
- int LA6_2 = input.LA(2);
+ int LA8_2 = input.LA(2);
- if ( (synpred14()) ) {
- alt6=1;
+ if ( (synpred17()) ) {
+ alt8=1;
}
else if ( (true) ) {
- alt6=2;
+ alt8=2;
}
else {
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("100:1: expr_list : ( expr SEPR expr_list -> ^( SEPR expr expr_list ) | expr );", 6, 2, input);
+ new NoViableAltException("115:1: expr_list : ( expr SEPR expr_list -> ^( SEPR expr expr_list ) | expr );", 8, 2, input);
throw nvae;
}
@@ -2291,18 +2736,18 @@
break;
case NUMBER:
{
- int LA6_3 = input.LA(2);
+ int LA8_3 = input.LA(2);
- if ( (synpred14()) ) {
- alt6=1;
+ if ( (synpred17()) ) {
+ alt8=1;
}
else if ( (true) ) {
- alt6=2;
+ alt8=2;
}
else {
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("100:1: expr_list : ( expr SEPR expr_list -> ^( SEPR expr expr_list ) | expr );", 6, 3, input);
+ new NoViableAltException("115:1: expr_list : ( expr SEPR expr_list -> ^( SEPR expr expr_list ) | expr );", 8, 3, input);
throw nvae;
}
@@ -2310,18 +2755,18 @@
break;
case STRING:
{
- int LA6_4 = input.LA(2);
+ int LA8_4 = input.LA(2);
- if ( (synpred14()) ) {
- alt6=1;
+ if ( (synpred17()) ) {
+ alt8=1;
}
else if ( (true) ) {
- alt6=2;
+ alt8=2;
}
else {
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("100:1: expr_list : ( expr SEPR expr_list -> ^( SEPR expr expr_list ) | expr );", 6, 4, input);
+ new NoViableAltException("115:1: expr_list : ( expr SEPR expr_list -> ^( SEPR expr expr_list ) | expr );", 8, 4, input);
throw nvae;
}
@@ -2329,18 +2774,18 @@
break;
case LPAREN:
{
- int LA6_5 = input.LA(2);
+ int LA8_5 = input.LA(2);
- if ( (synpred14()) ) {
- alt6=1;
+ if ( (synpred17()) ) {
+ alt8=1;
}
else if ( (true) ) {
- alt6=2;
+ alt8=2;
}
else {
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("100:1: expr_list : ( expr SEPR expr_list -> ^( SEPR expr expr_list ) | expr );", 6, 5, input);
+ new NoViableAltException("115:1: expr_list : ( expr SEPR expr_list -> ^( SEPR expr expr_list ) | expr );", 8, 5, input);
throw nvae;
}
@@ -2349,18 +2794,18 @@
case NOT:
case TWIDDLE:
{
- int LA6_6 = input.LA(2);
+ int LA8_6 = input.LA(2);
- if ( (synpred14()) ) {
- alt6=1;
+ if ( (synpred17()) ) {
+ alt8=1;
}
else if ( (true) ) {
- alt6=2;
+ alt8=2;
}
else {
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("100:1: expr_list : ( expr SEPR expr_list -> ^( SEPR expr expr_list ) | expr );", 6, 6, input);
+ new NoViableAltException("115:1: expr_list : ( expr SEPR expr_list -> ^( SEPR expr expr_list ) | expr );", 8, 6, input);
throw nvae;
}
@@ -2369,32 +2814,32 @@
default:
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("100:1: expr_list : ( expr SEPR expr_list -> ^( SEPR expr expr_list ) | expr );", 6, 0, input);
+ new NoViableAltException("115:1: expr_list : ( expr SEPR expr_list -> ^( SEPR expr expr_list ) | expr );", 8, 0, input);
throw nvae;
}
- switch (alt6) {
+ switch (alt8) {
case 1 :
- // dd/grammar/ECAGrammar.g:101:4: expr SEPR expr_list
+ // dd/grammar/ECAGrammar.g:116:4: expr SEPR expr_list
{
- pushFollow(FOLLOW_expr_in_expr_list584);
- expr46=expr();
+ pushFollow(FOLLOW_expr_in_expr_list734);
+ expr58=expr();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) stream_expr.add(expr46.getTree());
- SEPR47=(Token)input.LT(1);
- match(input,SEPR,FOLLOW_SEPR_in_expr_list586); if (failed) return retval;
- if ( backtracking==0 ) stream_SEPR.add(SEPR47);
+ if ( backtracking==0 ) stream_expr.add(expr58.getTree());
+ SEPR59=(Token)input.LT(1);
+ match(input,SEPR,FOLLOW_SEPR_in_expr_list736); if (failed) return retval;
+ if ( backtracking==0 ) stream_SEPR.add(SEPR59);
- pushFollow(FOLLOW_expr_list_in_expr_list588);
- expr_list48=expr_list();
+ pushFollow(FOLLOW_expr_list_in_expr_list738);
+ expr_list60=expr_list();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) stream_expr_list.add(expr_list48.getTree());
+ if ( backtracking==0 ) stream_expr_list.add(expr_list60.getTree());
// AST REWRITE
- // elements: expr, SEPR, expr_list
+ // elements: expr_list, SEPR, expr
// token labels:
// rule labels: retval
// token list labels:
@@ -2404,9 +2849,9 @@
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
root_0 = (Object)adaptor.nil();
- // 101:26: -> ^( SEPR expr expr_list )
+ // 116:26: -> ^( SEPR expr expr_list )
{
- // dd/grammar/ECAGrammar.g:101:29: ^( SEPR expr expr_list )
+ // dd/grammar/ECAGrammar.g:116:29: ^( SEPR expr expr_list )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_SEPR.next(), root_1);
@@ -2424,15 +2869,15 @@
}
break;
case 2 :
- // dd/grammar/ECAGrammar.g:102:4: expr
+ // dd/grammar/ECAGrammar.g:117:4: expr
{
root_0 = (Object)adaptor.nil();
- pushFollow(FOLLOW_expr_in_expr_list605);
- expr49=expr();
+ pushFollow(FOLLOW_expr_in_expr_list755);
+ expr61=expr();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) adaptor.addChild(root_0, expr49.getTree());
+ if ( backtracking==0 ) adaptor.addChild(root_0, expr61.getTree());
}
break;
@@ -2461,40 +2906,40 @@
};
// $ANTLR start array_idx_list
- // dd/grammar/ECAGrammar.g:105:1: array_idx_list : ( array_idx array_idx_list -> ^( SEPR array_idx array_idx_list ) | array_idx );
+ // dd/grammar/ECAGrammar.g:120:1: array_idx_list : ( array_idx array_idx_list -> ^( SEPR array_idx array_idx_list ) | array_idx );
public final array_idx_list_return array_idx_list() throws RecognitionException {
array_idx_list_return retval = new array_idx_list_return();
retval.start = input.LT(1);
Object root_0 = null;
- array_idx_return array_idx50 = null;
+ array_idx_return array_idx62 = null;
- array_idx_list_return array_idx_list51 = null;
+ array_idx_list_return array_idx_list63 = null;
- array_idx_return array_idx52 = null;
+ array_idx_return array_idx64 = null;
RewriteRuleSubtreeStream stream_array_idx=new RewriteRuleSubtreeStream(adaptor,"rule array_idx");
RewriteRuleSubtreeStream stream_array_idx_list=new RewriteRuleSubtreeStream(adaptor,"rule array_idx_list");
try {
- // dd/grammar/ECAGrammar.g:106:2: ( array_idx array_idx_list -> ^( SEPR array_idx array_idx_list ) | array_idx )
- int alt7=2;
- int LA7_0 = input.LA(1);
+ // dd/grammar/ECAGrammar.g:121:2: ( array_idx array_idx_list -> ^( SEPR array_idx array_idx_list ) | array_idx )
+ int alt9=2;
+ int LA9_0 = input.LA(1);
- if ( (LA7_0==LSQUARE) ) {
- int LA7_1 = input.LA(2);
+ if ( (LA9_0==LSQUARE) ) {
+ int LA9_1 = input.LA(2);
- if ( (synpred15()) ) {
- alt7=1;
+ if ( (synpred18()) ) {
+ alt9=1;
}
else if ( (true) ) {
- alt7=2;
+ alt9=2;
}
else {
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("105:1: array_idx_list : ( array_idx array_idx_list -> ^( SEPR array_idx array_idx_list ) | array_idx );", 7, 1, input);
+ new NoViableAltException("120:1: array_idx_list : ( array_idx array_idx_list -> ^( SEPR array_idx array_idx_list ) | array_idx );", 9, 1, input);
throw nvae;
}
@@ -2502,27 +2947,27 @@
else {
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("105:1: array_idx_list : ( array_idx array_idx_list -> ^( SEPR array_idx array_idx_list ) | array_idx );", 7, 0, input);
+ new NoViableAltException("120:1: array_idx_list : ( array_idx array_idx_list -> ^( SEPR array_idx array_idx_list ) | array_idx );", 9, 0, input);
throw nvae;
}
- switch (alt7) {
+ switch (alt9) {
case 1 :
- // dd/grammar/ECAGrammar.g:106:4: array_idx array_idx_list
+ // dd/grammar/ECAGrammar.g:121:4: array_idx array_idx_list
{
- pushFollow(FOLLOW_array_idx_in_array_idx_list616);
- array_idx50=array_idx();
+ pushFollow(FOLLOW_array_idx_in_array_idx_list766);
+ array_idx62=array_idx();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) stream_array_idx.add(array_idx50.getTree());
- pushFollow(FOLLOW_array_idx_list_in_array_idx_list618);
- array_idx_list51=array_idx_list();
+ if ( backtracking==0 ) stream_array_idx.add(array_idx62.getTree());
+ pushFollow(FOLLOW_array_idx_list_in_array_idx_list768);
+ array_idx_list63=array_idx_list();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) stream_array_idx_list.add(array_idx_list51.getTree());
+ if ( backtracking==0 ) stream_array_idx_list.add(array_idx_list63.getTree());
// AST REWRITE
- // elements: array_idx, array_idx_list
+ // elements: array_idx_list, array_idx
// token labels:
// rule labels: retval
// token list labels:
@@ -2532,9 +2977,9 @@
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
root_0 = (Object)adaptor.nil();
- // 106:31: -> ^( SEPR array_idx array_idx_list )
+ // 121:31: -> ^( SEPR array_idx array_idx_list )
{
- // dd/grammar/ECAGrammar.g:106:34: ^( SEPR array_idx array_idx_list )
+ // dd/grammar/ECAGrammar.g:121:34: ^( SEPR array_idx array_idx_list )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(adaptor.create(SEPR, "SEPR"), root_1);
@@ -2552,15 +2997,15 @@
}
break;
case 2 :
- // dd/grammar/ECAGrammar.g:107:4: array_idx
+ // dd/grammar/ECAGrammar.g:122:4: array_idx
{
root_0 = (Object)adaptor.nil();
- pushFollow(FOLLOW_array_idx_in_array_idx_list635);
- array_idx52=array_idx();
+ pushFollow(FOLLOW_array_idx_in_array_idx_list785);
+ array_idx64=array_idx();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) adaptor.addChild(root_0, array_idx52.getTree());
+ if ( backtracking==0 ) adaptor.addChild(root_0, array_idx64.getTree());
}
break;
@@ -2589,39 +3034,39 @@
};
// $ANTLR start array_idx
- // dd/grammar/ECAGrammar.g:110:1: array_idx : LSQUARE expr RSQUARE -> ^( expr ) ;
+ // dd/grammar/ECAGrammar.g:125:1: array_idx : LSQUARE expr RSQUARE -> ^( expr ) ;
public final array_idx_return array_idx() throws RecognitionException {
array_idx_return retval = new array_idx_return();
retval.start = input.LT(1);
Object root_0 = null;
- Token LSQUARE53=null;
- Token RSQUARE55=null;
- expr_return expr54 = null;
+ Token LSQUARE65=null;
+ Token RSQUARE67=null;
+ expr_return expr66 = null;
- Object LSQUARE53_tree=null;
- Object RSQUARE55_tree=null;
+ Object LSQUARE65_tree=null;
+ Object RSQUARE67_tree=null;
RewriteRuleTokenStream stream_LSQUARE=new RewriteRuleTokenStream(adaptor,"token LSQUARE");
RewriteRuleTokenStream stream_RSQUARE=new RewriteRuleTokenStream(adaptor,"token RSQUARE");
RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr");
try {
- // dd/grammar/ECAGrammar.g:111:2: ( LSQUARE expr RSQUARE -> ^( expr ) )
- // dd/grammar/ECAGrammar.g:111:4: LSQUARE expr RSQUARE
+ // dd/grammar/ECAGrammar.g:126:2: ( LSQUARE expr RSQUARE -> ^( expr ) )
+ // dd/grammar/ECAGrammar.g:126:4: LSQUARE expr RSQUARE
{
- LSQUARE53=(Token)input.LT(1);
- match(input,LSQUARE,FOLLOW_LSQUARE_in_array_idx646); if (failed) return retval;
- if ( backtracking==0 ) stream_LSQUARE.add(LSQUARE53);
+ LSQUARE65=(Token)input.LT(1);
+ match(input,LSQUARE,FOLLOW_LSQUARE_in_array_idx796); if (failed) return retval;
+ if ( backtracking==0 ) stream_LSQUARE.add(LSQUARE65);
- pushFollow(FOLLOW_expr_in_array_idx648);
- expr54=expr();
+ pushFollow(FOLLOW_expr_in_array_idx798);
+ expr66=expr();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) stream_expr.add(expr54.getTree());
- RSQUARE55=(Token)input.LT(1);
- match(input,RSQUARE,FOLLOW_RSQUARE_in_array_idx650); if (failed) return retval;
- if ( backtracking==0 ) stream_RSQUARE.add(RSQUARE55);
+ if ( backtracking==0 ) stream_expr.add(expr66.getTree());
+ RSQUARE67=(Token)input.LT(1);
+ match(input,RSQUARE,FOLLOW_RSQUARE_in_array_idx800); if (failed) return retval;
+ if ( backtracking==0 ) stream_RSQUARE.add(RSQUARE67);
// AST REWRITE
@@ -2635,9 +3080,9 @@
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
root_0 = (Object)adaptor.nil();
- // 111:27: -> ^( expr )
+ // 126:27: -> ^( expr )
{
- // dd/grammar/ECAGrammar.g:111:30: ^( expr )
+ // dd/grammar/ECAGrammar.g:126:30: ^( expr )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_expr.nextNode(), root_1);
@@ -2674,32 +3119,32 @@
};
// $ANTLR start infix_oper
- // dd/grammar/ECAGrammar.g:114:1: infix_oper : ( infix_bit_oper | infix_arith_oper | infix_bool_oper | infix_cmp_oper );
+ // dd/grammar/ECAGrammar.g:129:1: infix_oper : ( infix_bit_oper | infix_arith_oper | infix_bool_oper | infix_cmp_oper );
public final infix_oper_return infix_oper() throws RecognitionException {
infix_oper_return retval = new infix_oper_return();
retval.start = input.LT(1);
Object root_0 = null;
- infix_bit_oper_return infix_bit_oper56 = null;
+ infix_bit_oper_return infix_bit_oper68 = null;
- infix_arith_oper_return infix_arith_oper57 = null;
+ infix_arith_oper_return infix_arith_oper69 = null;
- infix_bool_oper_return infix_bool_oper58 = null;
+ infix_bool_oper_return infix_bool_oper70 = null;
- infix_cmp_oper_return infix_cmp_oper59 = null;
+ infix_cmp_oper_return infix_cmp_oper71 = null;
try {
- // dd/grammar/ECAGrammar.g:114:12: ( infix_bit_oper | infix_arith_oper | infix_bool_oper | infix_cmp_oper )
- int alt8=4;
+ // dd/grammar/ECAGrammar.g:129:12: ( infix_bit_oper | infix_arith_oper | infix_bool_oper | infix_cmp_oper )
+ int alt10=4;
switch ( input.LA(1) ) {
case BOR:
case BAND:
case BXOR:
{
- alt8=1;
+ alt10=1;
}
break;
case MUL:
@@ -2707,13 +3152,13 @@
case PLUS:
case MINUS:
{
- alt8=2;
+ alt10=2;
}
break;
case OR:
case AND:
{
- alt8=3;
+ alt10=3;
}
break;
case EQ:
@@ -2723,67 +3168,67 @@
case GEQ:
case LEQ:
{
- alt8=4;
+ alt10=4;
}
break;
default:
if (backtracking>0) {failed=true; return retval;}
NoViableAltException nvae =
- new NoViableAltException("114:1: infix_oper : ( infix_bit_oper | infix_arith_oper | infix_bool_oper | infix_cmp_oper );", 8, 0, input);
+ new NoViableAltException("129:1: infix_oper : ( infix_bit_oper | infix_arith_oper | infix_bool_oper | infix_cmp_oper );", 10, 0, input);
throw nvae;
}
- switch (alt8) {
+ switch (alt10) {
case 1 :
- // dd/grammar/ECAGrammar.g:114:14: infix_bit_oper
+ // dd/grammar/ECAGrammar.g:129:14: infix_bit_oper
{
root_0 = (Object)adaptor.nil();
- pushFollow(FOLLOW_infix_bit_oper_in_infix_oper668);
- infix_bit_oper56=infix_bit_oper();
+ pushFollow(FOLLOW_infix_bit_oper_in_infix_oper818);
+ infix_bit_oper68=infix_bit_oper();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) adaptor.addChild(root_0, infix_bit_oper56.getTree());
+ if ( backtracking==0 ) adaptor.addChild(root_0, infix_bit_oper68.getTree());
}
break;
case 2 :
- // dd/grammar/ECAGrammar.g:115:4: infix_arith_oper
+ // dd/grammar/ECAGrammar.g:130:4: infix_arith_oper
{
root_0 = (Object)adaptor.nil();
- pushFollow(FOLLOW_infix_arith_oper_in_infix_oper673);
- infix_arith_oper57=infix_arith_oper();
+ pushFollow(FOLLOW_infix_arith_oper_in_infix_oper823);
+ infix_arith_oper69=infix_arith_oper();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) adaptor.addChild(root_0, infix_arith_oper57.getTree());
+ if ( backtracking==0 ) adaptor.addChild(root_0, infix_arith_oper69.getTree());
}
break;
case 3 :
- // dd/grammar/ECAGrammar.g:116:4: infix_bool_oper
+ // dd/grammar/ECAGrammar.g:131:4: infix_bool_oper
{
root_0 = (Object)adaptor.nil();
- pushFollow(FOLLOW_infix_bool_oper_in_infix_oper678);
- infix_bool_oper58=infix_bool_oper();
+ pushFollow(FOLLOW_infix_bool_oper_in_infix_oper828);
+ infix_bool_oper70=infix_bool_oper();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) adaptor.addChild(root_0, infix_bool_oper58.getTree());
+ if ( backtracking==0 ) adaptor.addChild(root_0, infix_bool_oper70.getTree());
}
break;
case 4 :
- // dd/grammar/ECAGrammar.g:117:4: infix_cmp_oper
+ // dd/grammar/ECAGrammar.g:132:4: infix_cmp_oper
{
root_0 = (Object)adaptor.nil();
- pushFollow(FOLLOW_infix_cmp_oper_in_infix_oper683);
- infix_cmp_oper59=infix_cmp_oper();
+ pushFollow(FOLLOW_infix_cmp_oper_in_infix_oper833);
+ infix_cmp_oper71=infix_cmp_oper();
_fsp--;
if (failed) return retval;
- if ( backtracking==0 ) adaptor.addChild(root_0, infix_cmp_oper59.getTree());
+ if ( backtracking==0 ) adaptor.addChild(root_0, infix_cmp_oper71.getTree());
}
break;
@@ -2812,27 +3257,27 @@
};
// $ANTLR start infix_bit_oper
- // dd/grammar/ECAGrammar.g:120:1: infix_bit_oper : ( BAND | BOR | BXOR );
+ // dd/grammar/ECAGrammar.g:135:1: infix_bit_oper : ( BAND | BOR | BXOR );
public final infix_bit_oper_return infix_bit_oper() throws RecognitionException {
infix_bit_oper_return retval = new infix_bit_oper_return();
retval.start = input.LT(1);
Object root_0 = null;
- Token set60=null;
+ Token set72=null;
- Object set60_tree=null;
+ Object set72_tree=null;
try {
- // dd/grammar/ECAGrammar.g:121:2: ( BAND | BOR | BXOR )
+ // dd/grammar/ECAGrammar.g:136:2: ( BAND | BOR | BXOR )
// dd/grammar/ECAGrammar.g:
{
root_0 = (Object)adaptor.nil();
- set60=(Token)input.LT(1);
+ set72=(Token)input.LT(1);
if ( (input.LA(1)>=BOR && input.LA(1)<=BXOR) ) {
input.consume();
- if ( backtracking==0 ) adaptor.addChild(root_0, adaptor.create(set60));
+ if ( backtracking==0 ) adaptor.addChild(root_0, adaptor.create(set72));
errorRecovery=false;failed=false;
}
else {
@@ -2868,27 +3313,27 @@
};
// $ANTLR start infix_arith_oper
- // dd/grammar/ECAGrammar.g:126:1: infix_arith_oper : ( MUL | DIV | PLUS | MINUS );
+ // dd/grammar/ECAGrammar.g:141:1: infix_arith_oper : ( MUL | DIV | PLUS | MINUS );
public final infix_arith_oper_return infix_arith_oper() throws RecognitionException {
infix_arith_oper_return retval = new infix_arith_oper_return();
retval.start = input.LT(1);
Object root_0 = null;
- Token set61=null;
+ Token set73=null;
- Object set61_tree=null;
+ Object set73_tree=null;
try {
- // dd/grammar/ECAGrammar.g:127:2: ( MUL | DIV | PLUS | MINUS )
+ // dd/grammar/ECAGrammar.g:142:2: ( MUL | DIV | PLUS | MINUS )
// dd/grammar/ECAGrammar.g:
{
root_0 = (Object)adaptor.nil();
- set61=(Token)input.LT(1);
+ set73=(Token)input.LT(1);
if ( (input.LA(1)>=MUL && input.LA(1)<=MINUS) ) {
input.consume();
- if ( backtracking==0 ) adaptor.addChild(root_0, adaptor.create(set61));
+ if ( backtracking==0 ) adaptor.addChild(root_0, adaptor.create(set73));
errorRecovery=false;failed=false;
}
else {
@@ -2924,27 +3369,27 @@
};
// $ANTLR start infix_bool_oper
- // dd/grammar/ECAGrammar.g:133:1: infix_bool_oper : ( AND | OR );
+ // dd/grammar/ECAGrammar.g:148:1: infix_bool_oper : ( AND | OR );
public final infix_bool_oper_return infix_bool_oper() throws RecognitionException {
infix_bool_oper_return retval = new infix_bool_oper_return();
retval.start = input.LT(1);
Object root_0 = null;
- Token set62=null;
+ Token set74=null;
- Object set62_tree=null;
+ Object set74_tree=null;
try {
- // dd/grammar/ECAGrammar.g:134:2: ( AND | OR )
+ // dd/grammar/ECAGrammar.g:149:2: ( AND | OR )
// dd/grammar/ECAGrammar.g:
{
root_0 = (Object)adaptor.nil();
- set62=(Token)input.LT(1);
+ set74=(Token)input.LT(1);
if ( (input.LA(1)>=OR && input.LA(1)<=AND) ) {
input.consume();
- if ( backtracking==0 ) adaptor.addChild(root_0, adaptor.create(set62));
+ if ( backtracking==0 ) adaptor.addChild(root_0, adaptor.create(set74));
errorRecovery=false;failed=false;
}
else {
@@ -2980,27 +3425,27 @@
};
// $ANTLR start infix_cmp_oper
- // dd/grammar/ECAGrammar.g:138:1: infix_cmp_oper : ( EQ | NEQ | GT | LT | GEQ | LEQ );
+ // dd/grammar/ECAGrammar.g:153:1: infix_cmp_oper : ( EQ | NEQ | GT | LT | GEQ | LEQ );
public final infix_cmp_oper_return infix_cmp_oper() throws RecognitionException {
infix_cmp_oper_return retval = new infix_cmp_oper_return();
retval.start = input.LT(1);
Object root_0 = null;
- Token set63=null;
+ Token set75=null;
- Object set63_tree=null;
+ Object set75_tree=null;
try {
- // dd/grammar/ECAGrammar.g:139:2: ( EQ | NEQ | GT | LT | GEQ | LEQ )
+ // dd/grammar/ECAGrammar.g:154:2: ( EQ | NEQ | GT | LT | GEQ | LEQ )
// dd/grammar/ECAGrammar.g:
{
root_0 = (Object)adaptor.nil();
- set63=(Token)input.LT(1);
+ set75=(Token)input.LT(1);
if ( (input.LA(1)>=EQ && input.LA(1)<=LEQ) ) {
input.consume();
- if ( backtracking==0 ) adaptor.addChild(root_0, adaptor.create(set63));
+ if ( backtracking==0 ) adaptor.addChild(root_0, adaptor.create(set75));
errorRecovery=false;failed=false;
}
else {
@@ -3036,27 +3481,27 @@
};
// $ANTLR start unary_oper
- // dd/grammar/ECAGrammar.g:147:1: unary_oper : ( NOT | TWIDDLE );
+ // dd/grammar/ECAGrammar.g:162:1: unary_oper : ( NOT | TWIDDLE );
public final unary_oper_return unary_oper() throws RecognitionException {
unary_oper_return retval = new unary_oper_return();
retval.start = input.LT(1);
Object root_0 = null;
- Token set64=null;
+ Token set76=null;
- Object set64_tree=null;
+ Object set76_tree=null;
try {
- // dd/grammar/ECAGrammar.g:147:12: ( NOT | TWIDDLE )
+ // dd/grammar/ECAGrammar.g:162:12: ( NOT | TWIDDLE )
// dd/grammar/ECAGrammar.g:
{
root_0 = (Object)adaptor.nil();
- set64=(Token)input.LT(1);
+ set76=(Token)input.LT(1);
if ( input.LA(1)==NOT||input.LA(1)==TWIDDLE ) {
input.consume();
- if ( backtracking==0 ) adaptor.addChild(root_0, adaptor.create(set64));
+ if ( backtracking==0 ) adaptor.addChild(root_0, adaptor.create(set76));
errorRecovery=false;failed=false;
}
else {
@@ -3088,15 +3533,15 @@
// $ANTLR start synpred1
public final void synpred1_fragment() throws RecognitionException {
- // dd/grammar/ECAGrammar.g:50:12: ( binding SEPR bindings )
- // dd/grammar/ECAGrammar.g:50:12: binding SEPR bindings
+ // dd/grammar/ECAGrammar.g:62:12: ( binding SEPR bindings )
+ // dd/grammar/ECAGrammar.g:62:12: binding SEPR bindings
{
- pushFollow(FOLLOW_binding_in_synpred1218);
+ pushFollow(FOLLOW_binding_in_synpred1332);
binding();
_fsp--;
if (failed) return ;
- match(input,SEPR,FOLLOW_SEPR_in_synpred1220); if (failed) return ;
- pushFollow(FOLLOW_bindings_in_synpred1222);
+ match(input,SEPR,FOLLOW_SEPR_in_synpred1334); if (failed) return ;
+ pushFollow(FOLLOW_bindings_in_synpred1336);
bindings();
_fsp--;
if (failed) return ;
@@ -3105,103 +3550,103 @@
}
// $ANTLR end synpred1
- // $ANTLR start synpred3
- public final void synpred3_fragment() throws RecognitionException {
- // dd/grammar/ECAGrammar.g:77:4: ( action_expr SEPR action_expr_list )
- // dd/grammar/ECAGrammar.g:77:4: action_expr SEPR action_expr_list
+ // $ANTLR start synpred6
+ public final void synpred6_fragment() throws RecognitionException {
+ // dd/grammar/ECAGrammar.g:92:4: ( action_expr SEPR action_expr_list )
+ // dd/grammar/ECAGrammar.g:92:4: action_expr SEPR action_expr_list
{
- pushFollow(FOLLOW_action_expr_in_synpred3337);
+ pushFollow(FOLLOW_action_expr_in_synpred6487);
action_expr();
_fsp--;
if (failed) return ;
- match(input,SEPR,FOLLOW_SEPR_in_synpred3339); if (failed) return ;
- pushFollow(FOLLOW_action_expr_list_in_synpred3341);
+ match(input,SEPR,FOLLOW_SEPR_in_synpred6489); if (failed) return ;
+ pushFollow(FOLLOW_action_expr_list_in_synpred6491);
action_expr_list();
_fsp--;
if (failed) return ;
}
}
- // $ANTLR end synpred3
+ // $ANTLR end synpred6
- // $ANTLR start synpred4
- public final void synpred4_fragment() throws RecognitionException {
- // dd/grammar/ECAGrammar.g:84:8: ( simple_expr infix_oper expr )
- // dd/grammar/ECAGrammar.g:84:8: simple_expr infix_oper expr
+ // $ANTLR start synpred7
+ public final void synpred7_fragment() throws RecognitionException {
+ // dd/grammar/ECAGrammar.g:99:8: ( simple_expr infix_oper expr )
+ // dd/grammar/ECAGrammar.g:99:8: simple_expr infix_oper expr
{
- pushFollow(FOLLOW_simple_expr_in_synpred4376);
+ pushFollow(FOLLOW_simple_expr_in_synpred7526);
simple_expr();
_fsp--;
if (failed) return ;
- pushFollow(FOLLOW_infix_oper_in_synpred4378);
+ pushFollow(FOLLOW_infix_oper_in_synpred7528);
infix_oper();
_fsp--;
if (failed) return ;
- pushFollow(FOLLOW_expr_in_synpred4380);
+ pushFollow(FOLLOW_expr_in_synpred7530);
expr();
_fsp--;
if (failed) return ;
}
}
- // $ANTLR end synpred4
+ // $ANTLR end synpred7
- // $ANTLR start synpred5
- public final void synpred5_fragment() throws RecognitionException {
- // dd/grammar/ECAGrammar.g:85:4: ( simple_expr )
- // dd/grammar/ECAGrammar.g:85:4: simple_expr
+ // $ANTLR start synpred8
+ public final void synpred8_fragment() throws RecognitionException {
+ // dd/grammar/ECAGrammar.g:100:4: ( simple_expr )
+ // dd/grammar/ECAGrammar.g:100:4: simple_expr
{
- pushFollow(FOLLOW_simple_expr_in_synpred5398);
+ pushFollow(FOLLOW_simple_expr_in_synpred8548);
simple_expr();
_fsp--;
if (failed) return ;
}
}
- // $ANTLR end synpred5
+ // $ANTLR end synpred8
- // $ANTLR start synpred14
- public final void synpred14_fragment() throws RecognitionException {
- // dd/grammar/ECAGrammar.g:101:4: ( expr SEPR expr_list )
- // dd/grammar/ECAGrammar.g:101:4: expr SEPR expr_list
+ // $ANTLR start synpred17
+ public final void synpred17_fragment() throws RecognitionException {
+ // dd/grammar/ECAGrammar.g:116:4: ( expr SEPR expr_list )
+ // dd/grammar/ECAGrammar.g:116:4: expr SEPR expr_list
{
- pushFollow(FOLLOW_expr_in_synpred14584);
+ pushFollow(FOLLOW_expr_in_synpred17734);
expr();
_fsp--;
if (failed) return ;
- match(input,SEPR,FOLLOW_SEPR_in_synpred14586); if (failed) return ;
- pushFollow(FOLLOW_expr_list_in_synpred14588);
+ match(input,SEPR,FOLLOW_SEPR_in_synpred17736); if (failed) return ;
+ pushFollow(FOLLOW_expr_list_in_synpred17738);
expr_list();
_fsp--;
if (failed) return ;
}
}
- // $ANTLR end synpred14
+ // $ANTLR end synpred17
- // $ANTLR start synpred15
- public final void synpred15_fragment() throws RecognitionException {
- // dd/grammar/ECAGrammar.g:106:4: ( array_idx array_idx_list )
- // dd/grammar/ECAGrammar.g:106:4: array_idx array_idx_list
+ // $ANTLR start synpred18
+ public final void synpred18_fragment() throws RecognitionException {
+ // dd/grammar/ECAGrammar.g:121:4: ( array_idx array_idx_list )
+ // dd/grammar/ECAGrammar.g:121:4: array_idx array_idx_list
{
- pushFollow(FOLLOW_array_idx_in_synpred15616);
+ pushFollow(FOLLOW_array_idx_in_synpred18766);
array_idx();
_fsp--;
if (failed) return ;
- pushFollow(FOLLOW_array_idx_list_in_synpred15618);
+ pushFollow(FOLLOW_array_idx_list_in_synpred18768);
array_idx_list();
_fsp--;
if (failed) return ;
}
}
- // $ANTLR end synpred15
+ // $ANTLR end synpred18
- public final boolean synpred4() {
+ public final boolean synpred18() {
backtracking++;
int start = input.mark();
try {
- synpred4_fragment(); // can never throw exception
+ synpred18_fragment(); // can never throw exception
} catch (RecognitionException re) {
System.err.println("impossible: "+re);
}
@@ -3211,11 +3656,11 @@
failed=false;
return success;
}
- public final boolean synpred14() {
+ public final boolean synpred7() {
backtracking++;
int start = input.mark();
try {
- synpred14_fragment(); // can never throw exception
+ synpred7_fragment(); // can never throw exception
} catch (RecognitionException re) {
System.err.println("impossible: "+re);
}
@@ -3225,11 +3670,11 @@
failed=false;
return success;
}
- public final boolean synpred3() {
+ public final boolean synpred1() {
backtracking++;
int start = input.mark();
try {
- synpred3_fragment(); // can never throw exception
+ synpred1_fragment(); // can never throw exception
} catch (RecognitionException re) {
System.err.println("impossible: "+re);
}
@@ -3239,11 +3684,11 @@
failed=false;
return success;
}
- public final boolean synpred1() {
+ public final boolean synpred17() {
backtracking++;
int start = input.mark();
try {
- synpred1_fragment(); // can never throw exception
+ synpred17_fragment(); // can never throw exception
} catch (RecognitionException re) {
System.err.println("impossible: "+re);
}
@@ -3253,11 +3698,11 @@
failed=false;
return success;
}
- public final boolean synpred5() {
+ public final boolean synpred6() {
backtracking++;
int start = input.mark();
try {
- synpred5_fragment(); // can never throw exception
+ synpred6_fragment(); // can never throw exception
} catch (RecognitionException re) {
System.err.println("impossible: "+re);
}
@@ -3267,11 +3712,11 @@
failed=false;
return success;
}
- public final boolean synpred15() {
+ public final boolean synpred8() {
backtracking++;
int start = input.mark();
try {
- synpred15_fragment(); // can never throw exception
+ synpred8_fragment(); // can never throw exception
} catch (RecognitionException re) {
System.err.println("impossible: "+re);
}
@@ -3285,99 +3730,119 @@
- public static final BitSet FOLLOW_eca_in_eca_rule86 = new BitSet(new long[]{0x0000000000000000L});
- public static final BitSet FOLLOW_EOF_in_eca_rule88 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_event_in_eca_event105 = new BitSet(new long[]{0x0000000000000000L});
- public static final BitSet FOLLOW_EOF_in_eca_event107 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_condition_in_eca_condition123 = new BitSet(new long[]{0x0000000000000000L});
- public static final BitSet FOLLOW_EOF_in_eca_condition125 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_action_in_eca_action141 = new BitSet(new long[]{0x0000000000000000L});
- public static final BitSet FOLLOW_EOF_in_eca_action143 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_BIND_in_eca159 = new BitSet(new long[]{0x0100000000000000L});
- public static final BitSet FOLLOW_event_in_eca163 = new BitSet(new long[]{0x0000000000004000L});
- public static final BitSet FOLLOW_IF_in_eca167 = new BitSet(new long[]{0x0510002008011000L});
- public static final BitSet FOLLOW_condition_in_eca171 = new BitSet(new long[]{0x0000000000008000L});
- public static final BitSet FOLLOW_DO_in_eca175 = new BitSet(new long[]{0x0510002008011000L});
- public static final BitSet FOLLOW_action_in_eca179 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_bindings_in_event206 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_binding_in_bindings218 = new BitSet(new long[]{0x0000000000400000L});
- public static final BitSet FOLLOW_SEPR_in_bindings220 = new BitSet(new long[]{0x0100000000000000L});
- public static final BitSet FOLLOW_bindings_in_bindings222 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_binding_in_bindings237 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_bind_sym_in_binding247 = new BitSet(new long[]{0x0000000001000000L});
- public static final BitSet FOLLOW_ASSIGN_in_binding249 = new BitSet(new long[]{0x0510002008011000L});
- public static final BitSet FOLLOW_expr_in_binding251 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_SYMBOL_in_bind_sym274 = new BitSet(new long[]{0x0000100000000000L});
- public static final BitSet FOLLOW_COLON_in_bind_sym276 = new BitSet(new long[]{0x0100000000000000L});
- public static final BitSet FOLLOW_SYMBOL_in_bind_sym280 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_SYMBOL_in_bind_sym298 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_expr_in_condition312 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_action_expr_list_in_action326 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_action_expr_in_action_expr_list337 = new BitSet(new long[]{0x0000000000400000L});
- public static final BitSet FOLLOW_SEPR_in_action_expr_list339 = new BitSet(new long[]{0x0510002008011000L});
- public static final BitSet FOLLOW_action_expr_list_in_action_expr_list341 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_action_expr_in_action_expr_list356 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_expr_in_action_expr366 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_simple_expr_in_expr376 = new BitSet(new long[]{0x000003DFF6000000L});
- public static final BitSet FOLLOW_infix_oper_in_expr378 = new BitSet(new long[]{0x0510002008011000L});
- public static final BitSet FOLLOW_expr_in_expr380 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_simple_expr_in_expr398 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_unary_oper_in_expr403 = new BitSet(new long[]{0x0510002008011000L});
- public static final BitSet FOLLOW_expr_in_expr405 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_simple_expr_in_expr424 = new BitSet(new long[]{0x0000080000000000L});
- public static final BitSet FOLLOW_TERN_IF_in_expr426 = new BitSet(new long[]{0x0510002008011000L});
- public static final BitSet FOLLOW_expr_in_expr430 = new BitSet(new long[]{0x0000100000000000L});
- public static final BitSet FOLLOW_COLON_in_expr432 = new BitSet(new long[]{0x0510002008011000L});
- public static final BitSet FOLLOW_expr_in_expr436 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_DOLLARSYM_in_simple_expr463 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_SYMBOL_in_simple_expr470 = new BitSet(new long[]{0x0000000000040000L});
- public static final BitSet FOLLOW_array_idx_in_simple_expr474 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_SYMBOL_in_simple_expr495 = new BitSet(new long[]{0x0000000000010000L});
- public static final BitSet FOLLOW_LPAREN_in_simple_expr497 = new BitSet(new long[]{0x0000000000020000L});
- public static final BitSet FOLLOW_RPAREN_in_simple_expr499 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_SYMBOL_in_simple_expr517 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_SYMBOL_in_simple_expr524 = new BitSet(new long[]{0x0000000000010000L});
- public static final BitSet FOLLOW_LPAREN_in_simple_expr526 = new BitSet(new long[]{0x0510002008011000L});
- public static final BitSet FOLLOW_expr_list_in_simple_expr530 = new BitSet(new long[]{0x0000000000020000L});
- public static final BitSet FOLLOW_RPAREN_in_simple_expr532 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_NUMBER_in_simple_expr551 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_STRING_in_simple_expr556 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_LPAREN_in_simple_expr561 = new BitSet(new long[]{0x0510002008011000L});
- public static final BitSet FOLLOW_expr_in_simple_expr563 = new BitSet(new long[]{0x0000000000020000L});
- public static final BitSet FOLLOW_RPAREN_in_simple_expr565 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_expr_in_expr_list584 = new BitSet(new long[]{0x0000000000400000L});
- public static final BitSet FOLLOW_SEPR_in_expr_list586 = new BitSet(new long[]{0x0510002008011000L});
- public static final BitSet FOLLOW_expr_list_in_expr_list588 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_expr_in_expr_list605 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_array_idx_in_array_idx_list616 = new BitSet(new long[]{0x0000000000040000L});
- public static final BitSet FOLLOW_array_idx_list_in_array_idx_list618 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_array_idx_in_array_idx_list635 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_LSQUARE_in_array_idx646 = new BitSet(new long[]{0x0510002008011000L});
- public static final BitSet FOLLOW_expr_in_array_idx648 = new BitSet(new long[]{0x0000000000080000L});
- public static final BitSet FOLLOW_RSQUARE_in_array_idx650 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_infix_bit_oper_in_infix_oper668 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_infix_arith_oper_in_infix_oper673 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_infix_bool_oper_in_infix_oper678 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_infix_cmp_oper_in_infix_oper683 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_eca_script_rule_one_in_eca_script_rule88 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_eca_script_rule90 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_in_eca_script_rule_one107 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_SYMBOL_in_eca_script_rule_one111 = new BitSet(new long[]{0x0000000000020000L});
+ public static final BitSet FOLLOW_CLASS_in_eca_script_rule_one115 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_SYMBOL_in_eca_script_rule_one119 = new BitSet(new long[]{0x0000000000040000L});
+ public static final BitSet FOLLOW_METHOD_in_eca_script_rule_one123 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_SYMBOL_in_eca_script_rule_one127 = new BitSet(new long[]{0x0000000000080000L});
+ public static final BitSet FOLLOW_LINE_in_eca_script_rule_one131 = new BitSet(new long[]{0x0000000000001000L});
+ public static final BitSet FOLLOW_NUMBER_in_eca_script_rule_one135 = new BitSet(new long[]{0x0000000000002000L});
+ public static final BitSet FOLLOW_BIND_in_eca_script_rule_one139 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_event_in_eca_script_rule_one143 = new BitSet(new long[]{0x0000000000004000L});
+ public static final BitSet FOLLOW_IF_in_eca_script_rule_one147 = new BitSet(new long[]{0x1000200801C01000L,0x0000000000000005L});
+ public static final BitSet FOLLOW_condition_in_eca_script_rule_one151 = new BitSet(new long[]{0x0000000000008000L});
+ public static final BitSet FOLLOW_DO_in_eca_script_rule_one155 = new BitSet(new long[]{0x1000200801201000L,0x0000000000000005L});
+ public static final BitSet FOLLOW_action_in_eca_script_rule_one159 = new BitSet(new long[]{0x0000000000100000L});
+ public static final BitSet FOLLOW_ENDRULE_in_eca_script_rule_one163 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_eca_in_eca_rule200 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_eca_rule202 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_event_in_eca_event219 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_eca_event221 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_condition_in_eca_condition237 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_eca_condition239 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_action_in_eca_action255 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_eca_action257 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_BIND_in_eca273 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_event_in_eca277 = new BitSet(new long[]{0x0000000000004000L});
+ public static final BitSet FOLLOW_IF_in_eca281 = new BitSet(new long[]{0x1000200801C01000L,0x0000000000000005L});
+ public static final BitSet FOLLOW_condition_in_eca285 = new BitSet(new long[]{0x0000000000008000L});
+ public static final BitSet FOLLOW_DO_in_eca289 = new BitSet(new long[]{0x1000200801201000L,0x0000000000000005L});
+ public static final BitSet FOLLOW_action_in_eca293 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_bindings_in_event320 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_binding_in_bindings332 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_SEPR_in_bindings334 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_bindings_in_bindings336 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_binding_in_bindings351 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_bind_sym_in_binding361 = new BitSet(new long[]{0x0000000100000000L});
+ public static final BitSet FOLLOW_ASSIGN_in_binding363 = new BitSet(new long[]{0x1000200801001000L,0x0000000000000005L});
+ public static final BitSet FOLLOW_expr_in_binding365 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_SYMBOL_in_bind_sym388 = new BitSet(new long[]{0x0010000000000000L});
+ public static final BitSet FOLLOW_COLON_in_bind_sym390 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_SYMBOL_in_bind_sym394 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_SYMBOL_in_bind_sym412 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_TRUE_in_condition426 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_FALSE_in_condition438 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_expr_in_condition450 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_NOTHING_in_action464 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_action_expr_list_in_action476 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_action_expr_in_action_expr_list487 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_SEPR_in_action_expr_list489 = new BitSet(new long[]{0x1000200801001000L,0x0000000000000005L});
+ public static final BitSet FOLLOW_action_expr_list_in_action_expr_list491 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_action_expr_in_action_expr_list506 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_expr_in_action_expr516 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_simple_expr_in_expr526 = new BitSet(new long[]{0x0003DFF600000000L});
+ public static final BitSet FOLLOW_infix_oper_in_expr528 = new BitSet(new long[]{0x1000200801001000L,0x0000000000000005L});
+ public static final BitSet FOLLOW_expr_in_expr530 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_simple_expr_in_expr548 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_unary_oper_in_expr553 = new BitSet(new long[]{0x1000200801001000L,0x0000000000000005L});
+ public static final BitSet FOLLOW_expr_in_expr555 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_simple_expr_in_expr574 = new BitSet(new long[]{0x0008000000000000L});
+ public static final BitSet FOLLOW_TERN_IF_in_expr576 = new BitSet(new long[]{0x1000200801001000L,0x0000000000000005L});
+ public static final BitSet FOLLOW_expr_in_expr580 = new BitSet(new long[]{0x0010000000000000L});
+ public static final BitSet FOLLOW_COLON_in_expr582 = new BitSet(new long[]{0x1000200801001000L,0x0000000000000005L});
+ public static final BitSet FOLLOW_expr_in_expr586 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_DOLLARSYM_in_simple_expr613 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_SYMBOL_in_simple_expr620 = new BitSet(new long[]{0x0000000004000000L});
+ public static final BitSet FOLLOW_array_idx_in_simple_expr624 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_SYMBOL_in_simple_expr645 = new BitSet(new long[]{0x0000000001000000L});
+ public static final BitSet FOLLOW_LPAREN_in_simple_expr647 = new BitSet(new long[]{0x0000000002000000L});
+ public static final BitSet FOLLOW_RPAREN_in_simple_expr649 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_SYMBOL_in_simple_expr667 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_SYMBOL_in_simple_expr674 = new BitSet(new long[]{0x0000000001000000L});
+ public static final BitSet FOLLOW_LPAREN_in_simple_expr676 = new BitSet(new long[]{0x1000200801001000L,0x0000000000000005L});
+ public static final BitSet FOLLOW_expr_list_in_simple_expr680 = new BitSet(new long[]{0x0000000002000000L});
+ public static final BitSet FOLLOW_RPAREN_in_simple_expr682 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_NUMBER_in_simple_expr701 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_STRING_in_simple_expr706 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_LPAREN_in_simple_expr711 = new BitSet(new long[]{0x1000200801001000L,0x0000000000000005L});
+ public static final BitSet FOLLOW_expr_in_simple_expr713 = new BitSet(new long[]{0x0000000002000000L});
+ public static final BitSet FOLLOW_RPAREN_in_simple_expr715 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_expr_in_expr_list734 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_SEPR_in_expr_list736 = new BitSet(new long[]{0x1000200801001000L,0x0000000000000005L});
+ public static final BitSet FOLLOW_expr_list_in_expr_list738 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_expr_in_expr_list755 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_array_idx_in_array_idx_list766 = new BitSet(new long[]{0x0000000004000000L});
+ public static final BitSet FOLLOW_array_idx_list_in_array_idx_list768 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_array_idx_in_array_idx_list785 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_LSQUARE_in_array_idx796 = new BitSet(new long[]{0x1000200801001000L,0x0000000000000005L});
+ public static final BitSet FOLLOW_expr_in_array_idx798 = new BitSet(new long[]{0x0000000008000000L});
+ public static final BitSet FOLLOW_RSQUARE_in_array_idx800 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_infix_bit_oper_in_infix_oper818 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_infix_arith_oper_in_infix_oper823 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_infix_bool_oper_in_infix_oper828 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_infix_cmp_oper_in_infix_oper833 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_set_in_infix_bit_oper0 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_set_in_infix_arith_oper0 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_set_in_infix_bool_oper0 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_set_in_infix_cmp_oper0 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_set_in_unary_oper0 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_binding_in_synpred1218 = new BitSet(new long[]{0x0000000000400000L});
- public static final BitSet FOLLOW_SEPR_in_synpred1220 = new BitSet(new long[]{0x0100000000000000L});
- public static final BitSet FOLLOW_bindings_in_synpred1222 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_action_expr_in_synpred3337 = new BitSet(new long[]{0x0000000000400000L});
- public static final BitSet FOLLOW_SEPR_in_synpred3339 = new BitSet(new long[]{0x0510002008011000L});
- public static final BitSet FOLLOW_action_expr_list_in_synpred3341 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_simple_expr_in_synpred4376 = new BitSet(new long[]{0x000003DFF6000000L});
- public static final BitSet FOLLOW_infix_oper_in_synpred4378 = new BitSet(new long[]{0x0510002008011000L});
- public static final BitSet FOLLOW_expr_in_synpred4380 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_simple_expr_in_synpred5398 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_expr_in_synpred14584 = new BitSet(new long[]{0x0000000000400000L});
- public static final BitSet FOLLOW_SEPR_in_synpred14586 = new BitSet(new long[]{0x0510002008011000L});
- public static final BitSet FOLLOW_expr_list_in_synpred14588 = new BitSet(new long[]{0x0000000000000002L});
- public static final BitSet FOLLOW_array_idx_in_synpred15616 = new BitSet(new long[]{0x0000000000040000L});
- public static final BitSet FOLLOW_array_idx_list_in_synpred15618 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_binding_in_synpred1332 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_SEPR_in_synpred1334 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_bindings_in_synpred1336 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_action_expr_in_synpred6487 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_SEPR_in_synpred6489 = new BitSet(new long[]{0x1000200801001000L,0x0000000000000005L});
+ public static final BitSet FOLLOW_action_expr_list_in_synpred6491 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_simple_expr_in_synpred7526 = new BitSet(new long[]{0x0003DFF600000000L});
+ public static final BitSet FOLLOW_infix_oper_in_synpred7528 = new BitSet(new long[]{0x1000200801001000L,0x0000000000000005L});
+ public static final BitSet FOLLOW_expr_in_synpred7530 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_simple_expr_in_synpred8548 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_expr_in_synpred17734 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_SEPR_in_synpred17736 = new BitSet(new long[]{0x1000200801001000L,0x0000000000000005L});
+ public static final BitSet FOLLOW_expr_list_in_synpred17738 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_array_idx_in_synpred18766 = new BitSet(new long[]{0x0000000004000000L});
+ public static final BitSet FOLLOW_array_idx_list_in_synpred18768 = new BitSet(new long[]{0x0000000000000002L});
}
\ No newline at end of file
Modified: labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/grammar/ECATokenLexer.java
===================================================================
--- labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/grammar/ECATokenLexer.java 2008-09-23 08:42:24 UTC (rev 23006)
+++ labs/jbosstm/workspace/adinn/orchestration/src/org/jboss/jbossts/orchestration/rule/grammar/ECATokenLexer.java 2008-09-23 10:27:03 UTC (rev 23007)
@@ -1,4 +1,4 @@
-// $ANTLR 3.0.1 dd/grammar/ECAToken.g 2008-09-12 18:02:58
+// $ANTLR 3.0.1 dd/grammar/ECAToken.g 2008-09-22 16:26:17
package org.jboss.jbossts.orchestration.rule.grammar;
@@ -9,64 +9,72 @@
import java.util.ArrayList;
public class ECATokenLexer extends Lexer {
- public static final int MINUS=41;
+ public static final int MINUS=49;
public static final int NUMBER=12;
+ public static final int METHOD=18;
public static final int FLOAT=11;
+ public static final int FALSE=23;
public static final int POSDIGIT=5;
- public static final int LEQ=33;
- public static final int TWIDDLE=37;
- public static final int MOD=42;
- public static final int GEQ=32;
- public static final int DQUOTE=48;
- public static final int OR=25;
- public static final int BOR=34;
+ public static final int TWIDDLE=45;
+ public static final int LEQ=41;
+ public static final int RULE=16;
+ public static final int MOD=50;
+ public static final int GEQ=40;
+ public static final int DQUOTE=56;
+ public static final int OR=33;
+ public static final int BOR=42;
public static final int BAREINT=7;
- public static final int LBRACE=20;
- public static final int NEWLINE=50;
- public static final int DOT=23;
- public static final int RBRACE=21;
+ public static final int LBRACE=28;
+ public static final int NEWLINE=58;
+ public static final int DOT=31;
+ public static final int RBRACE=29;
public static final int INTEGER=8;
- public static final int AND=26;
- public static final int ASSIGN=24;
- public static final int SYMBOL=56;
- public static final int RPAREN=17;
- public static final int LPAREN=16;
+ public static final int AND=34;
+ public static final int ASSIGN=32;
+ public static final int SYMBOL=64;
+ public static final int RPAREN=25;
public static final int SIGN=6;
+ public static final int LPAREN=24;
+ public static final int PLUS=48;
public static final int DIGIT=4;
- public static final int PLUS=40;
- public static final int BAND=35;
- public static final int NEQ=29;
- public static final int SPACE=49;
- public static final int LETTER=45;
- public static final int LSQUARE=18;
+ public static final int LINE=19;
+ public static final int BAND=43;
+ public static final int NEQ=37;
+ public static final int SPACE=57;
+ public static final int LETTER=53;
+ public static final int LSQUARE=26;
public static final int DO=15;
public static final int POINT=9;
- public static final int BARESYM=53;
- public static final int SEPR=22;
- public static final int WS=59;
- public static final int STRING=52;
- public static final int EQ=28;
- public static final int QUOTSYM=54;
- public static final int LT=31;
- public static final int GT=30;
- public static final int DOLLAR=57;
- public static final int RSQUARE=19;
- public static final int QUOTE=47;
- public static final int TERN_IF=43;
- public static final int MUL=38;
+ public static final int BARESYM=61;
+ public static final int NOTHING=21;
+ public static final int SEPR=30;
+ public static final int WS=67;
+ public static final int STRING=60;
+ public static final int EQ=36;
+ public static final int QUOTSYM=62;
+ public static final int LT=39;
+ public static final int GT=38;
+ public static final int DOLLAR=65;
+ public static final int RSQUARE=27;
+ public static final int QUOTE=55;
+ public static final int TERN_IF=51;
+ public static final int MUL=46;
+ public static final int CLASS=17;
public static final int EXPPART=10;
- public static final int PUNCT=51;
+ public static final int PUNCT=59;
public static final int IF=14;
public static final int EOF=-1;
- public static final int Tokens=60;
- public static final int COLON=44;
- public static final int DIV=39;
- public static final int DOTSYM=55;
- public static final int BXOR=36;
+ public static final int Tokens=68;
+ public static final int COLON=52;
+ public static final int DIV=47;
+ public static final int DOTSYM=63;
+ public static final int BXOR=44;
+ public static final int ENDRULE=20;
public static final int BIND=13;
- public static final int NOT=27;
- public static final int UNDERSCORE=46;
- public static final int DOLLARSYM=58;
+ public static final int NOT=35;
+ public static final int TRUE=22;
+ public static final int UNDERSCORE=54;
+ public static final int DOLLARSYM=66;
public ECATokenLexer() {;}
public ECATokenLexer(CharStream input) {
super(input);
@@ -206,10 +214,10 @@
// $ANTLR start INTEGER
public final void mINTEGER() throws RecognitionException {
try {
- // dd/grammar/ECAToken.g:26:9: ( ( SIGN )? BAREINT )
- // dd/grammar/ECAToken.g:26:11: ( SIGN )? BAREINT
+ // dd/grammar/ECAToken.g:25:9: ( ( SIGN )? BAREINT )
+ // dd/grammar/ECAToken.g:25:11: ( SIGN )? BAREINT
{
- // dd/grammar/ECAToken.g:26:11: ( SIGN )?
+ // dd/grammar/ECAToken.g:25:11: ( SIGN )?
int alt3=2;
int LA3_0 = input.LA(1);
@@ -218,7 +226,7 @@
}
switch (alt3) {
case 1 :
- // dd/grammar/ECAToken.g:26:11: SIGN
+ // dd/grammar/ECAToken.g:25:11: SIGN
{
mSIGN();
@@ -240,8 +248,8 @@
// $ANTLR start POINT
public final void mPOINT() throws RecognitionException {
try {
- // dd/grammar/ECAToken.g:30:7: ( '.' )
- // dd/grammar/ECAToken.g:30:9: '.'
+ // dd/grammar/ECAToken.g:29:7: ( '.' )
+ // dd/grammar/ECAToken.g:29:9: '.'
{
match('.');
@@ -256,8 +264,8 @@
// $ANTLR start EXPPART
public final void mEXPPART() throws RecognitionException {
try {
- // dd/grammar/ECAToken.g:34:9: ( ( 'e' | 'E' ) INTEGER )
- // dd/grammar/ECAToken.g:34:12: ( 'e' | 'E' ) INTEGER
+ // dd/grammar/ECAToken.g:33:9: ( ( 'e' | 'E' ) INTEGER )
+ // dd/grammar/ECAToken.g:33:12: ( 'e' | 'E' ) INTEGER
{
if ( input.LA(1)=='E'||input.LA(1)=='e' ) {
input.consume();
@@ -282,12 +290,12 @@
// $ANTLR start FLOAT
public final void mFLOAT() throws RecognitionException {
try {
- // dd/grammar/ECAToken.g:39:7: ( INTEGER POINT ( BAREINT )? ( EXPPART )? )
- // dd/grammar/ECAToken.g:39:9: INTEGER POINT ( BAREINT )? ( EXPPART )?
+ // dd/grammar/ECAToken.g:38:7: ( INTEGER POINT ( BAREINT )? ( EXPPART )? )
+ // dd/grammar/ECAToken.g:38:9: INTEGER POINT ( BAREINT )? ( EXPPART )?
{
mINTEGER();
mPOINT();
- // dd/grammar/ECAToken.g:39:23: ( BAREINT )?
+ // dd/grammar/ECAToken.g:38:23: ( BAREINT )?
int alt4=2;
int LA4_0 = input.LA(1);
@@ -296,7 +304,7 @@
}
switch (alt4) {
case 1 :
- // dd/grammar/ECAToken.g:39:23: BAREINT
+ // dd/grammar/ECAToken.g:38:23: BAREINT
{
mBAREINT();
@@ -305,7 +313,7 @@
}
- // dd/grammar/ECAToken.g:39:32: ( EXPPART )?
+ // dd/grammar/ECAToken.g:38:32: ( EXPPART )?
int alt5=2;
int LA5_0 = input.LA(1);
@@ -314,7 +322,7 @@
}
switch (alt5) {
case 1 :
- // dd/grammar/ECAToken.g:39:32: EXPPART
+ // dd/grammar/ECAToken.g:38:32: EXPPART
{
mEXPPART();
@@ -336,19 +344,19 @@
public final void mNUMBER() throws RecognitionException {
try {
int _type = NUMBER;
- // dd/grammar/ECAToken.g:42:8: ( INTEGER | FLOAT )
+ // dd/grammar/ECAToken.g:41:8: ( INTEGER | FLOAT )
int alt6=2;
alt6 = dfa6.predict(input);
switch (alt6) {
case 1 :
- // dd/grammar/ECAToken.g:42:10: INTEGER
+ // dd/grammar/ECAToken.g:41:10: INTEGER
{
mINTEGER();
}
break;
case 2 :
- // dd/grammar/ECAToken.g:42:20: FLOAT
+ // dd/grammar/ECAToken.g:41:20: FLOAT
{
mFLOAT();
@@ -367,8 +375,8 @@
public final void mBIND() throws RecognitionException {
try {
int _type = BIND;
- // dd/grammar/ECAToken.g:47:6: ( 'BIND' )
- // dd/grammar/ECAToken.g:47:8: 'BIND'
+ // dd/grammar/ECAToken.g:46:6: ( 'BIND' )
+ // dd/grammar/ECAToken.g:46:8: 'BIND'
{
match("BIND");
@@ -386,8 +394,8 @@
public final void mIF() throws RecognitionException {
try {
int _type = IF;
- // dd/grammar/ECAToken.g:50:4: ( 'IF' )
- // dd/grammar/ECAToken.g:50:6: 'IF'
+ // dd/grammar/ECAToken.g:49:4: ( 'IF' )
+ // dd/grammar/ECAToken.g:49:6: 'IF'
{
match("IF");
@@ -405,8 +413,8 @@
public final void mDO() throws RecognitionException {
try {
int _type = DO;
- // dd/grammar/ECAToken.g:53:4: ( 'DO' )
- // dd/grammar/ECAToken.g:53:6: 'DO'
+ // dd/grammar/ECAToken.g:52:4: ( 'DO' )
+ // dd/grammar/ECAToken.g:52:6: 'DO'
{
match("DO");
@@ -420,12 +428,218 @@
}
// $ANTLR end DO
+ // $ANTLR start RULE
+ public final void mRULE() throws RecognitionException {
+ try {
+ int _type = RULE;
+ // dd/grammar/ECAToken.g:55:6: ( 'RULE' )
+ // dd/grammar/ECAToken.g:55:8: 'RULE'
+ {
+ match("RULE");
+
+
+ }
+
+ this.type = _type;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end RULE
+
+ // $ANTLR start CLASS
+ public final void mCLASS() throws RecognitionException {
+ try {
+ int _type = CLASS;
+ // dd/grammar/ECAToken.g:58:7: ( 'CLASS' )
+ // dd/grammar/ECAToken.g:58:9: 'CLASS'
+ {
+ match("CLASS");
+
+
+ }
+
+ this.type = _type;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end CLASS
+
+ // $ANTLR start METHOD
+ public final void mMETHOD() throws RecognitionException {
+ try {
+ int _type = METHOD;
+ // dd/grammar/ECAToken.g:61:8: ( 'METHOD' )
+ // dd/grammar/ECAToken.g:61:10: 'METHOD'
+ {
+ match("METHOD");
+
+
+ }
+
+ this.type = _type;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end METHOD
+
+ // $ANTLR start LINE
+ public final void mLINE() throws RecognitionException {
+ try {
+ int _type = LINE;
+ // dd/grammar/ECAToken.g:64:6: ( 'LINE' )
+ // dd/grammar/ECAToken.g:64:8: 'LINE'
+ {
+ match("LINE");
+
+
+ }
+
+ this.type = _type;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end LINE
+
+ // $ANTLR start ENDRULE
+ public final void mENDRULE() throws RecognitionException {
+ try {
+ int _type = ENDRULE;
+ // dd/grammar/ECAToken.g:67:9: ( 'ENDRULE' )
+ // dd/grammar/ECAToken.g:67:11: 'ENDRULE'
+ {
+ match("ENDRULE");
+
+
+ }
+
+ this.type = _type;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end ENDRULE
+
+ // $ANTLR start NOTHING
+ public final void mNOTHING() throws RecognitionException {
+ try {
+ int _type = NOTHING;
+ // dd/grammar/ECAToken.g:70:9: ( 'NOTHING' )
+ // dd/grammar/ECAToken.g:70:11: 'NOTHING'
+ {
+ match("NOTHING");
+
+
+ }
+
+ this.type = _type;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end NOTHING
+
+ // $ANTLR start TRUE
+ public final void mTRUE() throws RecognitionException {
+ try {
+ int _type = TRUE;
+ // dd/grammar/ECAToken.g:73:6: ( 'TRUE' | 'true' )
+ int alt7=2;
+ int LA7_0 = input.LA(1);
+
+ if ( (LA7_0=='T') ) {
+ alt7=1;
+ }
+ else if ( (LA7_0=='t') ) {
+ alt7=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("73:1: TRUE : ( 'TRUE' | 'true' );", 7, 0, input);
+
+ throw nvae;
+ }
+ switch (alt7) {
+ case 1 :
+ // dd/grammar/ECAToken.g:73:9: 'TRUE'
+ {
+ match("TRUE");
+
+
+ }
+ break;
+ case 2 :
+ // dd/grammar/ECAToken.g:73:18: 'true'
+ {
+ match("true");
+
+
+ }
+ break;
+
+ }
+ this.type = _type;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end TRUE
+
+ // $ANTLR start FALSE
+ public final void mFALSE() throws RecognitionException {
+ try {
+ int _type = FALSE;
+ // dd/grammar/ECAToken.g:76:7: ( 'FALSE' | 'false' )
+ int alt8=2;
+ int LA8_0 = input.LA(1);
+
+ if ( (LA8_0=='F') ) {
+ alt8=1;
+ }
+ else if ( (LA8_0=='f') ) {
+ alt8=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("76:1: FALSE : ( 'FALSE' | 'false' );", 8, 0, input);
+
+ throw nvae;
+ }
+ switch (alt8) {
+ case 1 :
+ // dd/grammar/ECAToken.g:76:9: 'FALSE'
+ {
+ match("FALSE");
+
+
+ }
+ break;
+ case 2 :
+ // dd/grammar/ECAToken.g:76:17: 'false'
+ {
+ match("false");
+
+
+ }
+ break;
+
+ }
+ this.type = _type;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end FALSE
+
// $ANTLR start LPAREN
public final void mLPAREN() throws RecognitionException {
try {
int _type = LPAREN;
- // dd/grammar/ECAToken.g:58:8: ( '(' )
- // dd/grammar/ECAToken.g:58:10: '('
+ // dd/grammar/ECAToken.g:81:8: ( '(' )
+ // dd/grammar/ECAToken.g:81:10: '('
{
match('(');
@@ -442,8 +656,8 @@
public final void mRPAREN() throws RecognitionException {
try {
int _type = RPAREN;
- // dd/grammar/ECAToken.g:61:8: ( ')' )
- // dd/grammar/ECAToken.g:61:10: ')'
+ // dd/grammar/ECAToken.g:84:8: ( ')' )
+ // dd/grammar/ECAToken.g:84:10: ')'
{
match(')');
@@ -460,8 +674,8 @@
public final void mLSQUARE() throws RecognitionException {
try {
int _type = LSQUARE;
- // dd/grammar/ECAToken.g:64:9: ( '\\[' )
- // dd/grammar/ECAToken.g:64:11: '\\['
+ // dd/grammar/ECAToken.g:87:9: ( '\\[' )
+ // dd/grammar/ECAToken.g:87:11: '\\['
{
match('[');
@@ -478,8 +692,8 @@
public final void mRSQUARE() throws RecognitionException {
try {
int _type = RSQUARE;
- // dd/grammar/ECAToken.g:67:9: ( '\\]' )
- // dd/grammar/ECAToken.g:67:11: '\\]'
+ // dd/grammar/ECAToken.g:90:9: ( '\\]' )
+ // dd/grammar/ECAToken.g:90:11: '\\]'
{
match(']');
@@ -496,8 +710,8 @@
public final void mLBRACE() throws RecognitionException {
try {
int _type = LBRACE;
- // dd/grammar/ECAToken.g:70:8: ( '{' )
- // dd/grammar/ECAToken.g:70:10: '{'
+ // dd/grammar/ECAToken.g:93:8: ( '{' )
+ // dd/grammar/ECAToken.g:93:10: '{'
{
match('{');
@@ -514,8 +728,8 @@
public final void mRBRACE() throws RecognitionException {
try {
int _type = RBRACE;
- // dd/grammar/ECAToken.g:73:8: ( '}' )
- // dd/grammar/ECAToken.g:73:10: '}'
+ // dd/grammar/ECAToken.g:96:8: ( '}' )
+ // dd/grammar/ECAToken.g:96:10: '}'
{
match('}');
@@ -532,7 +746,7 @@
public final void mSEPR() throws RecognitionException {
try {
int _type = SEPR;
- // dd/grammar/ECAToken.g:78:6: ( ';' | ',' )
+ // dd/grammar/ECAToken.g:101:6: ( ';' | ',' )
// dd/grammar/ECAToken.g:
{
if ( input.LA(1)==','||input.LA(1)==';' ) {
@@ -559,8 +773,8 @@
public final void mDOT() throws RecognitionException {
try {
int _type = DOT;
- // dd/grammar/ECAToken.g:84:5: ( '.' )
- // dd/grammar/ECAToken.g:84:7: '.'
+ // dd/grammar/ECAToken.g:107:5: ( '.' )
+ // dd/grammar/ECAToken.g:107:7: '.'
{
match('.');
@@ -577,32 +791,32 @@
public final void mASSIGN() throws RecognitionException {
try {
int _type = ASSIGN;
- // dd/grammar/ECAToken.g:89:8: ( '=' | '<--' )
- int alt7=2;
- int LA7_0 = input.LA(1);
+ // dd/grammar/ECAToken.g:112:8: ( '=' | '<--' )
+ int alt9=2;
+ int LA9_0 = input.LA(1);
- if ( (LA7_0=='=') ) {
- alt7=1;
+ if ( (LA9_0=='=') ) {
+ alt9=1;
}
- else if ( (LA7_0=='<') ) {
- alt7=2;
+ else if ( (LA9_0=='<') ) {
+ alt9=2;
}
else {
NoViableAltException nvae =
- new NoViableAltException("89:1: ASSIGN : ( '=' | '<--' );", 7, 0, input);
+ new NoViableAltException("112:1: ASSIGN : ( '=' | '<--' );", 9, 0, input);
throw nvae;
}
- switch (alt7) {
+ switch (alt9) {
case 1 :
- // dd/grammar/ECAToken.g:89:10: '='
+ // dd/grammar/ECAToken.g:112:10: '='
{
match('=');
}
break;
case 2 :
- // dd/grammar/ECAToken.g:90:4: '<--'
+ // dd/grammar/ECAToken.g:113:4: '<--'
{
match("<--");
@@ -622,34 +836,34 @@
public final void mOR() throws RecognitionException {
try {
int _type = OR;
- // dd/grammar/ECAToken.g:95:4: ( '||' | 'OR' | 'or' )
- int alt8=3;
+ // dd/grammar/ECAToken.g:118:4: ( '||' | 'OR' | 'or' )
+ int alt10=3;
switch ( input.LA(1) ) {
case '|':
{
- alt8=1;
+ alt10=1;
}
break;
case 'O':
{
- alt8=2;
+ alt10=2;
}
break;
case 'o':
{
- alt8=3;
+ alt10=3;
}
break;
default:
NoViableAltException nvae =
- new NoViableAltException("95:1: OR : ( '||' | 'OR' | 'or' );", 8, 0, input);
+ new NoViableAltException("118:1: OR : ( '||' | 'OR' | 'or' );", 10, 0, input);
throw nvae;
}
- switch (alt8) {
+ switch (alt10) {
case 1 :
- // dd/grammar/ECAToken.g:95:6: '||'
+ // dd/grammar/ECAToken.g:118:6: '||'
{
match("||");
@@ -657,7 +871,7 @@
}
break;
case 2 :
- // dd/grammar/ECAToken.g:96:4: 'OR'
+ // dd/grammar/ECAToken.g:119:4: 'OR'
{
match("OR");
@@ -665,7 +879,7 @@
}
break;
case 3 :
- // dd/grammar/ECAToken.g:97:4: 'or'
+ // dd/grammar/ECAToken.g:120:4: 'or'
{
match("or");
@@ -685,34 +899,34 @@
public final void mAND() throws RecognitionException {
try {
int _type = AND;
- // dd/grammar/ECAToken.g:100:5: ( '&&' | 'AND' | 'and' )
- int alt9=3;
+ // dd/grammar/ECAToken.g:123:5: ( '&&' | 'AND' | 'and' )
+ int alt11=3;
switch ( input.LA(1) ) {
case '&':
{
- alt9=1;
+ alt11=1;
}
break;
case 'A':
{
- alt9=2;
+ alt11=2;
}
break;
case 'a':
{
- alt9=3;
+ alt11=3;
}
break;
default:
NoViableAltException nvae =
- new NoViableAltException("100:1: AND : ( '&&' | 'AND' | 'and' );", 9, 0, input);
+ new NoViableAltException("123:1: AND : ( '&&' | 'AND' | 'and' );", 11, 0, input);
throw nvae;
}
- switch (alt9) {
+ switch (alt11) {
case 1 :
- // dd/grammar/ECAToken.g:100:7: '&&'
+ // dd/grammar/ECAToken.g:123:7: '&&'
{
match("&&");
@@ -720,7 +934,7 @@
}
break;
case 2 :
- // dd/grammar/ECAToken.g:101:4: 'AND'
+ // dd/grammar/ECAToken.g:124:4: 'AND'
{
match("AND");
@@ -728,7 +942,7 @@
}
break;
case 3 :
- // dd/grammar/ECAToken.g:102:4: 'and'
+ // dd/grammar/ECAToken.g:125:4: 'and'
{
match("and");
@@ -748,41 +962,41 @@
public final void mNOT() throws RecognitionException {
try {
int _type = NOT;
- // dd/grammar/ECAToken.g:105:5: ( '!' | 'NOT' | 'not' )
- int alt10=3;
+ // dd/grammar/ECAToken.g:128:5: ( '!' | 'NOT' | 'not' )
+ int alt12=3;
switch ( input.LA(1) ) {
case '!':
{
- alt10=1;
+ alt12=1;
}
break;
case 'N':
{
- alt10=2;
+ alt12=2;
}
break;
case 'n':
{
- alt10=3;
+ alt12=3;
}
break;
default:
NoViableAltException nvae =
- new NoViableAltException("105:1: NOT : ( '!' | 'NOT' | 'not' );", 10, 0, input);
+ new NoViableAltException("128:1: NOT : ( '!' | 'NOT' | 'not' );", 12, 0, input);
throw nvae;
}
- switch (alt10) {
+ switch (alt12) {
case 1 :
- // dd/grammar/ECAToken.g:105:7: '!'
+ // dd/grammar/ECAToken.g:128:7: '!'
{
match('!');
}
break;
case 2 :
- // dd/grammar/ECAToken.g:106:4: 'NOT'
+ // dd/grammar/ECAToken.g:129:4: 'NOT'
{
match("NOT");
@@ -790,7 +1004,7 @@
}
break;
case 3 :
- // dd/grammar/ECAToken.g:107:4: 'not'
+ // dd/grammar/ECAToken.g:130:4: 'not'
{
match("not");
@@ -810,34 +1024,34 @@
public final void mEQ() throws RecognitionException {
try {
int _type = EQ;
- // dd/grammar/ECAToken.g:112:4: ( '==' | 'EQ' | 'eq' )
- int alt11=3;
+ // dd/grammar/ECAToken.g:135:4: ( '==' | 'EQ' | 'eq' )
+ int alt13=3;
switch ( input.LA(1) ) {
case '=':
{
- alt11=1;
+ alt13=1;
}
break;
case 'E':
{
- alt11=2;
+ alt13=2;
}
break;
case 'e':
{
- alt11=3;
+ alt13=3;
}
break;
default:
NoViableAltException nvae =
- new NoViableAltException("112:1: EQ : ( '==' | 'EQ' | 'eq' );", 11, 0, input);
+ new NoViableAltException("135:1: EQ : ( '==' | 'EQ' | 'eq' );", 13, 0, input);
throw nvae;
}
- switch (alt11) {
+ switch (alt13) {
case 1 :
- // dd/grammar/ECAToken.g:112:6: '=='
+ // dd/grammar/ECAToken.g:135:6: '=='
{
match("==");
@@ -845,7 +1059,7 @@
}
break;
case 2 :
- // dd/grammar/ECAToken.g:113:4: 'EQ'
+ // dd/grammar/ECAToken.g:136:4: 'EQ'
{
match("EQ");
@@ -853,7 +1067,7 @@
}
break;
case 3 :
- // dd/grammar/ECAToken.g:114:4: 'eq'
+ // dd/grammar/ECAToken.g:137:4: 'eq'
{
match("eq");
@@ -873,34 +1087,34 @@
public final void mNEQ() throws RecognitionException {
try {
int _type = NEQ;
- // dd/grammar/ECAToken.g:117:5: ( '!=' | 'NEQ' | 'neq' )
- int alt12=3;
+ // dd/grammar/ECAToken.g:140:5: ( '!=' | 'NEQ' | 'neq' )
+ int alt14=3;
switch ( input.LA(1) ) {
case '!':
{
- alt12=1;
+ alt14=1;
}
break;
case 'N':
{
- alt12=2;
+ alt14=2;
}
break;
case 'n':
{
- alt12=3;
+ alt14=3;
}
break;
default:
NoViableAltException nvae =
- new NoViableAltException("117:1: NEQ : ( '!=' | 'NEQ' | 'neq' );", 12, 0, input);
+ new NoViableAltException("140:1: NEQ : ( '!=' | 'NEQ' | 'neq' );", 14, 0, input);
throw nvae;
}
- switch (alt12) {
+ switch (alt14) {
case 1 :
- // dd/grammar/ECAToken.g:117:7: '!='
+ // dd/grammar/ECAToken.g:140:7: '!='
{
match("!=");
@@ -908,7 +1122,7 @@
}
break;
case 2 :
- // dd/grammar/ECAToken.g:118:4: 'NEQ'
+ // dd/grammar/ECAToken.g:141:4: 'NEQ'
{
match("NEQ");
@@ -916,7 +1130,7 @@
}
break;
case 3 :
- // dd/grammar/ECAToken.g:119:4: 'neq'
+ // dd/grammar/ECAToken.g:142:4: 'neq'
{
match("neq");
@@ -936,41 +1150,41 @@
public final void mGT() throws RecognitionException {
try {
int _type = GT;
- // dd/grammar/ECAToken.g:122:4: ( '>' | 'GT' | 'gt' )
- int alt13=3;
+ // dd/grammar/ECAToken.g:145:4: ( '>' | 'GT' | 'gt' )
+ int alt15=3;
switch ( input.LA(1) ) {
case '>':
{
- alt13=1;
+ alt15=1;
}
break;
case 'G':
{
- alt13=2;
+ alt15=2;
}
break;
case 'g':
{
- alt13=3;
+ alt15=3;
}
break;
default:
NoViableAltException nvae =
- new NoViableAltException("122:1: GT : ( '>' | 'GT' | 'gt' );", 13, 0, input);
+ new NoViableAltException("145:1: GT : ( '>' | 'GT' | 'gt' );", 15, 0, input);
throw nvae;
}
- switch (alt13) {
+ switch (alt15) {
case 1 :
- // dd/grammar/ECAToken.g:122:6: '>'
+ // dd/grammar/ECAToken.g:145:6: '>'
{
match('>');
}
break;
case 2 :
- // dd/grammar/ECAToken.g:123:4: 'GT'
+ // dd/grammar/ECAToken.g:146:4: 'GT'
{
match("GT");
@@ -978,7 +1192,7 @@
}
break;
case 3 :
- // dd/grammar/ECAToken.g:124:4: 'gt'
+ // dd/grammar/ECAToken.g:147:4: 'gt'
{
match("gt");
@@ -998,41 +1212,41 @@
public final void mLT() throws RecognitionException {
try {
int _type = LT;
- // dd/grammar/ECAToken.g:127:4: ( '<' | 'LT' | 'lt' )
- int alt14=3;
+ // dd/grammar/ECAToken.g:150:4: ( '<' | 'LT' | 'lt' )
+ int alt16=3;
switch ( input.LA(1) ) {
case '<':
{
- alt14=1;
+ alt16=1;
}
break;
case 'L':
{
- alt14=2;
+ alt16=2;
}
break;
case 'l':
{
- alt14=3;
+ alt16=3;
}
break;
default:
NoViableAltException nvae =
- new NoViableAltException("127:1: LT : ( '<' | 'LT' | 'lt' );", 14, 0, input);
+ new NoViableAltException("150:1: LT : ( '<' | 'LT' | 'lt' );", 16, 0, input);
throw nvae;
}
- switch (alt14) {
+ switch (alt16) {
case 1 :
- // dd/grammar/ECAToken.g:127:6: '<'
+ // dd/grammar/ECAToken.g:150:6: '<'
{
match('<');
}
break;
case 2 :
- // dd/grammar/ECAToken.g:128:4: 'LT'
+ // dd/grammar/ECAToken.g:151:4: 'LT'
{
match("LT");
@@ -1040,7 +1254,7 @@
}
break;
case 3 :
- // dd/grammar/ECAToken.g:129:4: 'lt'
+ // dd/grammar/ECAToken.g:152:4: 'lt'
{
match("lt");
@@ -1060,34 +1274,34 @@
public final void mGEQ() throws RecognitionException {
try {
int _type = GEQ;
- // dd/grammar/ECAToken.g:132:5: ( '>=' | 'GEQ' | 'geq' )
- int alt15=3;
+ // dd/grammar/ECAToken.g:155:5: ( '>=' | 'EQ' | 'geq' )
+ int alt17=3;
switch ( input.LA(1) ) {
case '>':
{
- alt15=1;
+ alt17=1;
}
break;
- case 'G':
+ case 'E':
{
- alt15=2;
+ alt17=2;
}
break;
case 'g':
{
- alt15=3;
+ alt17=3;
}
break;
default:
NoViableAltException nvae =
- new NoViableAltException("132:1: GEQ : ( '>=' | 'GEQ' | 'geq' );", 15, 0, input);
+ new NoViableAltException("155:1: GEQ : ( '>=' | 'EQ' | 'geq' );", 17, 0, input);
throw nvae;
}
- switch (alt15) {
+ switch (alt17) {
case 1 :
- // dd/grammar/ECAToken.g:132:7: '>='
+ // dd/grammar/ECAToken.g:155:7: '>='
{
match(">=");
@@ -1095,15 +1309,15 @@
}
break;
case 2 :
- // dd/grammar/ECAToken.g:133:4: 'GEQ'
+ // dd/grammar/ECAToken.g:156:4: 'EQ'
{
- match("GEQ");
+ match("EQ");
}
break;
case 3 :
- // dd/grammar/ECAToken.g:134:4: 'geq'
+ // dd/grammar/ECAToken.g:157:4: 'geq'
{
match("geq");
@@ -1123,34 +1337,34 @@
public final void mLEQ() throws RecognitionException {
try {
int _type = LEQ;
- // dd/grammar/ECAToken.g:137:5: ( '<=' | 'LEQ' | 'leq' )
- int alt16=3;
+ // dd/grammar/ECAToken.g:160:5: ( '<=' | 'LEQ' | 'leq' )
+ int alt18=3;
switch ( input.LA(1) ) {
case '<':
{
- alt16=1;
+ alt18=1;
}
break;
case 'L':
{
- alt16=2;
+ alt18=2;
}
break;
case 'l':
{
- alt16=3;
+ alt18=3;
}
break;
default:
NoViableAltException nvae =
- new NoViableAltException("137:1: LEQ : ( '<=' | 'LEQ' | 'leq' );", 16, 0, input);
+ new NoViableAltException("160:1: LEQ : ( '<=' | 'LEQ' | 'leq' );", 18, 0, input);
throw nvae;
}
- switch (alt16) {
+ switch (alt18) {
case 1 :
- // dd/grammar/ECAToken.g:137:7: '<='
+ // dd/grammar/ECAToken.g:160:7: '<='
{
match("<=");
@@ -1158,7 +1372,7 @@
}
break;
case 2 :
- // dd/grammar/ECAToken.g:138:4: 'LEQ'
+ // dd/grammar/ECAToken.g:161:4: 'LEQ'
{
match("LEQ");
@@ -1166,7 +1380,7 @@
}
break;
case 3 :
- // dd/grammar/ECAToken.g:139:4: 'leq'
+ // dd/grammar/ECAToken.g:162:4: 'leq'
{
match("leq");
@@ -1186,8 +1400,8 @@
public final void mBOR() throws RecognitionException {
try {
int _type = BOR;
- // dd/grammar/ECAToken.g:144:5: ( '|' )
- // dd/grammar/ECAToken.g:144:7: '|'
+ // dd/grammar/ECAToken.g:167:5: ( '|' )
+ // dd/grammar/ECAToken.g:167:7: '|'
{
match('|');
@@ -1204,8 +1418,8 @@
public final void mBAND() throws RecognitionException {
try {
int _type = BAND;
- // dd/grammar/ECAToken.g:147:6: ( '&' )
- // dd/grammar/ECAToken.g:147:8: '&'
+ // dd/grammar/ECAToken.g:170:6: ( '&' )
+ // dd/grammar/ECAToken.g:170:8: '&'
{
match('&');
@@ -1222,8 +1436,8 @@
public final void mBXOR() throws RecognitionException {
try {
int _type = BXOR;
- // dd/grammar/ECAToken.g:150:6: ( '^' )
- // dd/grammar/ECAToken.g:150:8: '^'
+ // dd/grammar/ECAToken.g:173:6: ( '^' )
+ // dd/grammar/ECAToken.g:173:8: '^'
{
match('^');
@@ -1240,8 +1454,8 @@
public final void mTWIDDLE() throws RecognitionException {
try {
int _type = TWIDDLE;
- // dd/grammar/ECAToken.g:153:9: ( '~' )
- // dd/grammar/ECAToken.g:153:11: '~'
+ // dd/grammar/ECAToken.g:176:9: ( '~' )
+ // dd/grammar/ECAToken.g:176:11: '~'
{
match('~');
@@ -1258,41 +1472,41 @@
public final void mMUL() throws RecognitionException {
try {
int _type = MUL;
- // dd/grammar/ECAToken.g:158:5: ( '*' | 'TIMES' | 'times' )
- int alt17=3;
+ // dd/grammar/ECAToken.g:181:5: ( '*' | 'TIMES' | 'times' )
+ int alt19=3;
switch ( input.LA(1) ) {
case '*':
{
- alt17=1;
+ alt19=1;
}
break;
case 'T':
{
- alt17=2;
+ alt19=2;
}
break;
case 't':
{
- alt17=3;
+ alt19=3;
}
break;
default:
NoViableAltException nvae =
- new NoViableAltException("158:1: MUL : ( '*' | 'TIMES' | 'times' );", 17, 0, input);
+ new NoViableAltException("181:1: MUL : ( '*' | 'TIMES' | 'times' );", 19, 0, input);
throw nvae;
}
- switch (alt17) {
+ switch (alt19) {
case 1 :
- // dd/grammar/ECAToken.g:158:7: '*'
+ // dd/grammar/ECAToken.g:181:7: '*'
{
match('*');
}
break;
case 2 :
- // dd/grammar/ECAToken.g:159:4: 'TIMES'
+ // dd/grammar/ECAToken.g:182:4: 'TIMES'
{
match("TIMES");
@@ -1300,7 +1514,7 @@
}
break;
case 3 :
- // dd/grammar/ECAToken.g:160:4: 'times'
+ // dd/grammar/ECAToken.g:183:4: 'times'
{
match("times");
@@ -1320,41 +1534,41 @@
public final void mDIV() throws RecognitionException {
try {
int _type = DIV;
- // dd/grammar/ECAToken.g:163:5: ( '/' | 'DIVIDE' | 'divide' )
- int alt18=3;
+ // dd/grammar/ECAToken.g:186:5: ( '/' | 'DIVIDE' | 'divide' )
+ int alt20=3;
switch ( input.LA(1) ) {
case '/':
{
- alt18=1;
+ alt20=1;
}
break;
case 'D':
{
- alt18=2;
+ alt20=2;
}
break;
case 'd':
{
- alt18=3;
+ alt20=3;
}
break;
default:
NoViableAltException nvae =
- new NoViableAltException("163:1: DIV : ( '/' | 'DIVIDE' | 'divide' );", 18, 0, input);
+ new NoViableAltException("186:1: DIV : ( '/' | 'DIVIDE' | 'divide' );", 20, 0, input);
throw nvae;
}
- switch (alt18) {
+ switch (alt20) {
case 1 :
- // dd/grammar/ECAToken.g:163:7: '/'
+ // dd/grammar/ECAToken.g:186:7: '/'
{
match('/');
}
break;
case 2 :
- // dd/grammar/ECAToken.g:164:4: 'DIVIDE'
+ // dd/grammar/ECAToken.g:187:4: 'DIVIDE'
{
match("DIVIDE");
@@ -1362,7 +1576,7 @@
}
break;
case 3 :
- // dd/grammar/ECAToken.g:165:4: 'divide'
+ // dd/grammar/ECAToken.g:188:4: 'divide'
{
match("divide");
@@ -1382,41 +1596,41 @@
public final void mPLUS() throws RecognitionException {
try {
int _type = PLUS;
- // dd/grammar/ECAToken.g:168:6: ( '+' | 'PLUS' | 'plus' )
- int alt19=3;
+ // dd/grammar/ECAToken.g:191:6: ( '+' | 'PLUS' | 'plus' )
+ int alt21=3;
switch ( input.LA(1) ) {
case '+':
{
- alt19=1;
+ alt21=1;
}
break;
case 'P':
{
- alt19=2;
+ alt21=2;
}
break;
case 'p':
{
- alt19=3;
+ alt21=3;
}
break;
default:
NoViableAltException nvae =
- new NoViableAltException("168:1: PLUS : ( '+' | 'PLUS' | 'plus' );", 19, 0, input);
+ new NoViableAltException("191:1: PLUS : ( '+' | 'PLUS' | 'plus' );", 21, 0, input);
throw nvae;
}
- switch (alt19) {
+ switch (alt21) {
case 1 :
- // dd/grammar/ECAToken.g:168:8: '+'
+ // dd/grammar/ECAToken.g:191:8: '+'
{
match('+');
}
break;
case 2 :
- // dd/grammar/ECAToken.g:169:4: 'PLUS'
+ // dd/grammar/ECAToken.g:192:4: 'PLUS'
{
match("PLUS");
@@ -1424,7 +1638,7 @@
}
break;
case 3 :
- // dd/grammar/ECAToken.g:170:4: 'plus'
+ // dd/grammar/ECAToken.g:193:4: 'plus'
{
match("plus");
@@ -1444,41 +1658,41 @@
public final void mMINUS() throws RecognitionException {
try {
int _type = MINUS;
- // dd/grammar/ECAToken.g:173:7: ( '-' | 'MINUS' | 'minus' )
- int alt20=3;
+ // dd/grammar/ECAToken.g:196:7: ( '-' | 'MINUS' | 'minus' )
+ int alt22=3;
switch ( input.LA(1) ) {
case '-':
{
- alt20=1;
+ alt22=1;
}
break;
case 'M':
{
- alt20=2;
+ alt22=2;
}
break;
case 'm':
{
- alt20=3;
+ alt22=3;
}
break;
default:
NoViableAltException nvae =
- new NoViableAltException("173:1: MINUS : ( '-' | 'MINUS' | 'minus' );", 20, 0, input);
+ new NoViableAltException("196:1: MINUS : ( '-' | 'MINUS' | 'minus' );", 22, 0, input);
throw nvae;
}
- switch (alt20) {
+ switch (alt22) {
case 1 :
- // dd/grammar/ECAToken.g:173:9: '-'
+ // dd/grammar/ECAToken.g:196:9: '-'
{
match('-');
}
break;
case 2 :
- // dd/grammar/ECAToken.g:174:4: 'MINUS'
+ // dd/grammar/ECAToken.g:197:4: 'MINUS'
{
match("MINUS");
@@ -1486,7 +1700,7 @@
}
break;
case 3 :
- // dd/grammar/ECAToken.g:175:4: 'minus'
+ // dd/grammar/ECAToken.g:198:4: 'minus'
{
match("minus");
@@ -1506,41 +1720,41 @@
public final void mMOD() throws RecognitionException {
try {
int _type = MOD;
- // dd/grammar/ECAToken.g:178:5: ( '%' | 'MOD' | 'mod' )
- int alt21=3;
+ // dd/grammar/ECAToken.g:201:5: ( '%' | 'MOD' | 'mod' )
+ int alt23=3;
switch ( input.LA(1) ) {
case '%':
{
- alt21=1;
+ alt23=1;
}
break;
case 'M':
{
- alt21=2;
+ alt23=2;
}
break;
case 'm':
{
- alt21=3;
+ alt23=3;
}
break;
default:
NoViableAltException nvae =
- new NoViableAltException("178:1: MOD : ( '%' | 'MOD' | 'mod' );", 21, 0, input);
+ new NoViableAltException("201:1: MOD : ( '%' | 'MOD' | 'mod' );", 23, 0, input);
throw nvae;
}
- switch (alt21) {
+ switch (alt23) {
case 1 :
- // dd/grammar/ECAToken.g:178:7: '%'
+ // dd/grammar/ECAToken.g:201:7: '%'
{
match('%');
}
break;
case 2 :
- // dd/grammar/ECAToken.g:179:4: 'MOD'
+ // dd/grammar/ECAToken.g:202:4: 'MOD'
{
match("MOD");
@@ -1548,7 +1762,7 @@
}
break;
case 3 :
- // dd/grammar/ECAToken.g:180:4: 'mod'
+ // dd/grammar/ECAToken.g:203:4: 'mod'
{
match("mod");
@@ -1568,8 +1782,8 @@
public final void mTERN_IF() throws RecognitionException {
try {
int _type = TERN_IF;
- // dd/grammar/ECAToken.g:185:9: ( '?' )
- // dd/grammar/ECAToken.g:185:11: '?'
+ // dd/grammar/ECAToken.g:208:9: ( '?' )
+ // dd/grammar/ECAToken.g:208:11: '?'
{
match('?');
@@ -1586,8 +1800,8 @@
public final void mCOLON() throws RecognitionException {
try {
int _type = COLON;
- // dd/grammar/ECAToken.g:188:7: ( ':' )
- // dd/grammar/ECAToken.g:188:9: ':'
+ // dd/grammar/ECAToken.g:211:7: ( ':' )
+ // dd/grammar/ECAToken.g:211:9: ':'
{
match(':');
@@ -1603,7 +1817,7 @@
// $ANTLR start LETTER
public final void mLETTER() throws RecognitionException {
try {
- // dd/grammar/ECAToken.g:194:8: ( 'a' .. 'z' | 'A' .. 'Z' )
+ // dd/grammar/ECAToken.g:217:8: ( 'a' .. 'z' | 'A' .. 'Z' )
// dd/grammar/ECAToken.g:
{
if ( (input.LA(1)>='A' && input.LA(1)<='Z')||(input.LA(1)>='a' && input.LA(1)<='z') ) {
@@ -1628,8 +1842,8 @@
// $ANTLR start UNDERSCORE
public final void mUNDERSCORE() throws RecognitionException {
try {
- // dd/grammar/ECAToken.g:198:12: ( '_' )
- // dd/grammar/ECAToken.g:198:14: '_'
+ // dd/grammar/ECAToken.g:221:12: ( '_' )
+ // dd/grammar/ECAToken.g:221:14: '_'
{
match('_');
@@ -1645,8 +1859,8 @@
public final void mQUOTE() throws RecognitionException {
try {
int _type = QUOTE;
- // dd/grammar/ECAToken.g:201:7: ( '\\'' )
- // dd/grammar/ECAToken.g:201:9: '\\''
+ // dd/grammar/ECAToken.g:224:7: ( '\\'' )
+ // dd/grammar/ECAToken.g:224:9: '\\''
{
match('\'');
@@ -1663,8 +1877,8 @@
public final void mDQUOTE() throws RecognitionException {
try {
int _type = DQUOTE;
- // dd/grammar/ECAToken.g:204:8: ( '\"' )
- // dd/grammar/ECAToken.g:204:10: '\"'
+ // dd/grammar/ECAToken.g:227:8: ( '\"' )
+ // dd/grammar/ECAToken.g:227:10: '\"'
{
match('\"');
@@ -1680,7 +1894,7 @@
// $ANTLR start SPACE
public final void mSPACE() throws RecognitionException {
try {
- // dd/grammar/ECAToken.g:208:7: ( ' ' | '\\t' | '\\r' )
+ // dd/grammar/ECAToken.g:231:7: ( ' ' | '\\t' | '\\r' )
// dd/grammar/ECAToken.g:
{
if ( input.LA(1)=='\t'||input.LA(1)=='\r'||input.LA(1)==' ' ) {
@@ -1705,8 +1919,8 @@
// $ANTLR start NEWLINE
public final void mNEWLINE() throws RecognitionException {
try {
- // dd/grammar/ECAToken.g:212:9: ( '\\n' )
- // dd/grammar/ECAToken.g:212:11: '\\n'
+ // dd/grammar/ECAToken.g:235:9: ( '\\n' )
+ // dd/grammar/ECAToken.g:235:11: '\\n'
{
match('\n');
@@ -1721,7 +1935,7 @@
// $ANTLR start PUNCT
public final void mPUNCT() throws RecognitionException {
try {
- // dd/grammar/ECAToken.g:216:7: ( '!' | '$' | '%' | '^' | '&' | '*' | '(' | ')' | '-' | '+' | '=' | '{' | '}' | '[' | ']' | ':' | ';' | '@' | '~' | '#' | '|' | '\\\\' | '`' | ',' | '<' | '.' | '>' | '/' | '?' )
+ // dd/grammar/ECAToken.g:239:7: ( '!' | '$' | '%' | '^' | '&' | '*' | '(' | ')' | '-' | '+' | '=' | '{' | '}' | '[' | ']' | ':' | ';' | '@' | '~' | '#' | '|' | '\\\\' | '`' | ',' | '<' | '.' | '>' | '/' | '?' )
// dd/grammar/ECAToken.g:
{
if ( input.LA(1)=='!'||(input.LA(1)>='#' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='/')||(input.LA(1)>=':' && input.LA(1)<='@')||(input.LA(1)>='[' && input.LA(1)<='^')||input.LA(1)=='`'||(input.LA(1)>='{' && input.LA(1)<='~') ) {
@@ -1747,22 +1961,22 @@
public final void mSTRING() throws RecognitionException {
try {
int _type = STRING;
- // dd/grammar/ECAToken.g:219:8: ( DQUOTE ( SPACE | PUNCT | LETTER | UNDERSCORE | DIGIT | QUOTE )* DQUOTE )
- // dd/grammar/ECAToken.g:219:10: DQUOTE ( SPACE | PUNCT | LETTER | UNDERSCORE | DIGIT | QUOTE )* DQUOTE
+ // dd/grammar/ECAToken.g:242:8: ( DQUOTE ( SPACE | PUNCT | LETTER | UNDERSCORE | DIGIT | QUOTE )* DQUOTE )
+ // dd/grammar/ECAToken.g:242:10: DQUOTE ( SPACE | PUNCT | LETTER | UNDERSCORE | DIGIT | QUOTE )* DQUOTE
{
mDQUOTE();
- // dd/grammar/ECAToken.g:219:17: ( SPACE | PUNCT | LETTER | UNDERSCORE | DIGIT | QUOTE )*
- loop22:
+ // dd/grammar/ECAToken.g:242:17: ( SPACE | PUNCT | LETTER | UNDERSCORE | DIGIT | QUOTE )*
+ loop24:
do {
- int alt22=2;
- int LA22_0 = input.LA(1);
+ int alt24=2;
+ int LA24_0 = input.LA(1);
- if ( (LA22_0=='\t'||LA22_0=='\r'||(LA22_0>=' ' && LA22_0<='!')||(LA22_0>='#' && LA22_0<='~')) ) {
- alt22=1;
+ if ( (LA24_0=='\t'||LA24_0=='\r'||(LA24_0>=' ' && LA24_0<='!')||(LA24_0>='#' && LA24_0<='~')) ) {
+ alt24=1;
}
- switch (alt22) {
+ switch (alt24) {
case 1 :
// dd/grammar/ECAToken.g:
{
@@ -1781,7 +1995,7 @@
break;
default :
- break loop22;
+ break loop24;
}
} while (true);
@@ -1799,8 +2013,8 @@
// $ANTLR start BARESYM
public final void mBARESYM() throws RecognitionException {
try {
- // dd/grammar/ECAToken.g:223:9: ( ( LETTER | UNDERSCORE ) ( LETTER | DIGIT | UNDERSCORE )* )
- // dd/grammar/ECAToken.g:223:11: ( LETTER | UNDERSCORE ) ( LETTER | DIGIT | UNDERSCORE )*
+ // dd/grammar/ECAToken.g:246:9: ( ( LETTER | UNDERSCORE ) ( LETTER | DIGIT | UNDERSCORE )* )
+ // dd/grammar/ECAToken.g:246:11: ( LETTER | UNDERSCORE ) ( LETTER | DIGIT | UNDERSCORE )*
{
if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
input.consume();
@@ -1812,18 +2026,18 @@
recover(mse); throw mse;
}
- // dd/grammar/ECAToken.g:223:33: ( LETTER | DIGIT | UNDERSCORE )*
- loop23:
+ // dd/grammar/ECAToken.g:246:33: ( LETTER | DIGIT | UNDERSCORE )*
+ loop25:
do {
- int alt23=2;
- int LA23_0 = input.LA(1);
+ int alt25=2;
+ int LA25_0 = input.LA(1);
- if ( ((LA23_0>='0' && LA23_0<='9')||(LA23_0>='A' && LA23_0<='Z')||LA23_0=='_'||(LA23_0>='a' && LA23_0<='z')) ) {
- alt23=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 (alt23) {
+ switch (alt25) {
case 1 :
// dd/grammar/ECAToken.g:
{
@@ -1842,7 +2056,7 @@
break;
default :
- break loop23;
+ break loop25;
}
} while (true);
@@ -1858,26 +2072,26 @@
// $ANTLR start QUOTSYM
public final void mQUOTSYM() throws RecognitionException {
try {
- // dd/grammar/ECAToken.g:226:9: ( QUOTE ( PUNCT | LETTER | UNDERSCORE | DIGIT | DQUOTE )* QUOTE )
- // dd/grammar/ECAToken.g:226:11: QUOTE ( PUNCT | LETTER | UNDERSCORE | DIGIT | DQUOTE )* QUOTE
+ // dd/grammar/ECAToken.g:249:9: ( QUOTE ( PUNCT | LETTER | UNDERSCORE | DIGIT | DQUOTE | SPACE )* QUOTE )
+ // dd/grammar/ECAToken.g:249:11: QUOTE ( PUNCT | LETTER | UNDERSCORE | DIGIT | DQUOTE | SPACE )* QUOTE
{
mQUOTE();
- // dd/grammar/ECAToken.g:226:17: ( PUNCT | LETTER | UNDERSCORE | DIGIT | DQUOTE )*
- loop24:
+ // dd/grammar/ECAToken.g:249:17: ( PUNCT | LETTER | UNDERSCORE | DIGIT | DQUOTE | SPACE )*
+ loop26:
do {
- int alt24=2;
- int LA24_0 = input.LA(1);
+ int alt26=2;
+ int LA26_0 = input.LA(1);
- if ( ((LA24_0>='!' && LA24_0<='&')||(LA24_0>='(' && LA24_0<='~')) ) {
- alt24=1;
+ if ( (LA26_0=='\t'||LA26_0=='\r'||(LA26_0>=' ' && LA26_0<='&')||(LA26_0>='(' && LA26_0<='~')) ) {
+ alt26=1;
}
- switch (alt24) {
+ switch (alt26) {
case 1 :
// dd/grammar/ECAToken.g:
{
- if ( (input.LA(1)>='!' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='~') ) {
+ if ( input.LA(1)=='\t'||input.LA(1)=='\r'||(input.LA(1)>=' ' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='~') ) {
input.consume();
}
@@ -1892,7 +2106,7 @@
break;
default :
- break loop24;
+ break loop26;
}
} while (true);
@@ -1909,12 +2123,12 @@
// $ANTLR start DOTSYM
public final void mDOTSYM() throws RecognitionException {
try {
- // dd/grammar/ECAToken.g:231:8: ( BARESYM DOT DOTSYM | BARESYM )
- int alt25=2;
- alt25 = dfa25.predict(input);
- switch (alt25) {
+ // dd/grammar/ECAToken.g:254:8: ( BARESYM DOT DOTSYM | BARESYM )
+ int alt27=2;
+ alt27 = dfa27.predict(input);
+ switch (alt27) {
case 1 :
- // dd/grammar/ECAToken.g:231:10: BARESYM DOT DOTSYM
+ // dd/grammar/ECAToken.g:254:10: BARESYM DOT DOTSYM
{
mBARESYM();
mDOT();
@@ -1923,7 +2137,7 @@
}
break;
case 2 :
- // dd/grammar/ECAToken.g:232:4: BARESYM
+ // dd/grammar/ECAToken.g:255:4: BARESYM
{
mBARESYM();
@@ -1941,32 +2155,32 @@
public final void mSYMBOL() throws RecognitionException {
try {
int _type = SYMBOL;
- // dd/grammar/ECAToken.g:235:8: ( DOTSYM | QUOTSYM )
- int alt26=2;
- int LA26_0 = input.LA(1);
+ // dd/grammar/ECAToken.g:258:8: ( DOTSYM | QUOTSYM )
+ int alt28=2;
+ int LA28_0 = input.LA(1);
- if ( ((LA26_0>='A' && LA26_0<='Z')||LA26_0=='_'||(LA26_0>='a' && LA26_0<='z')) ) {
- alt26=1;
+ if ( ((LA28_0>='A' && LA28_0<='Z')||LA28_0=='_'||(LA28_0>='a' && LA28_0<='z')) ) {
+ alt28=1;
}
- else if ( (LA26_0=='\'') ) {
- alt26=2;
+ else if ( (LA28_0=='\'') ) {
+ alt28=2;
}
else {
NoViableAltException nvae =
- new NoViableAltException("235:1: SYMBOL : ( DOTSYM | QUOTSYM );", 26, 0, input);
+ new NoViableAltException("258:1: SYMBOL : ( DOTSYM | QUOTSYM );", 28, 0, input);
throw nvae;
}
- switch (alt26) {
+ switch (alt28) {
case 1 :
- // dd/grammar/ECAToken.g:235:10: DOTSYM
+ // dd/grammar/ECAToken.g:258:10: DOTSYM
{
mDOTSYM();
}
break;
case 2 :
- // dd/grammar/ECAToken.g:236:4: QUOTSYM
+ // dd/grammar/ECAToken.g:259:4: QUOTSYM
{
mQUOTSYM();
@@ -1984,8 +2198,8 @@
// $ANTLR start DOLLAR
public final void mDOLLAR() throws RecognitionException {
try {
- // dd/grammar/ECAToken.g:241:8: ( '$' )
- // dd/grammar/ECAToken.g:241:10: '$'
+ // dd/grammar/ECAToken.g:264:8: ( '$' )
+ // dd/grammar/ECAToken.g:264:10: '$'
{
match('$');
@@ -2001,36 +2215,36 @@
public final void mDOLLARSYM() throws RecognitionException {
try {
int _type = DOLLARSYM;
- // dd/grammar/ECAToken.g:246:11: ( DOLLAR ( BAREINT | BARESYM ) )
- // dd/grammar/ECAToken.g:246:13: DOLLAR ( BAREINT | BARESYM )
+ // dd/grammar/ECAToken.g:269:11: ( DOLLAR ( BAREINT | BARESYM ) )
+ // dd/grammar/ECAToken.g:269:13: DOLLAR ( BAREINT | BARESYM )
{
mDOLLAR();
- // dd/grammar/ECAToken.g:246:20: ( BAREINT | BARESYM )
- int alt27=2;
- int LA27_0 = input.LA(1);
+ // dd/grammar/ECAToken.g:269:20: ( BAREINT | BARESYM )
+ int alt29=2;
+ int LA29_0 = input.LA(1);
- if ( ((LA27_0>='0' && LA27_0<='9')) ) {
- alt27=1;
+ if ( ((LA29_0>='0' && LA29_0<='9')) ) {
+ alt29=1;
}
- else if ( ((LA27_0>='A' && LA27_0<='Z')||LA27_0=='_'||(LA27_0>='a' && LA27_0<='z')) ) {
- alt27=2;
+ else if ( ((LA29_0>='A' && LA29_0<='Z')||LA29_0=='_'||(LA29_0>='a' && LA29_0<='z')) ) {
+ alt29=2;
}
else {
NoViableAltException nvae =
- new NoViableAltException("246:20: ( BAREINT | BARESYM )", 27, 0, input);
+ new NoViableAltException("269:20: ( BAREINT | BARESYM )", 29, 0, input);
throw nvae;
}
- switch (alt27) {
+ switch (alt29) {
case 1 :
- // dd/grammar/ECAToken.g:246:21: BAREINT
+ // dd/grammar/ECAToken.g:269:21: BAREINT
{
mBAREINT();
}
break;
case 2 :
- // dd/grammar/ECAToken.g:246:31: BARESYM
+ // dd/grammar/ECAToken.g:269:31: BARESYM
{
mBARESYM();
@@ -2053,8 +2267,8 @@
public final void mWS() throws RecognitionException {
try {
int _type = WS;
- // dd/grammar/ECAToken.g:252:4: ( ( SPACE | NEWLINE ) )
- // dd/grammar/ECAToken.g:252:6: ( SPACE | NEWLINE )
+ // dd/grammar/ECAToken.g:275:4: ( ( SPACE | NEWLINE ) )
+ // dd/grammar/ECAToken.g:275:6: ( SPACE | NEWLINE )
{
if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) {
input.consume();
@@ -2078,18 +2292,18 @@
// $ANTLR end WS
public void mTokens() throws RecognitionException {
- // dd/grammar/ECAToken.g:1:8: ( NUMBER | BIND | IF | DO | LPAREN | RPAREN | LSQUARE | RSQUARE | LBRACE | RBRACE | SEPR | DOT | ASSIGN | OR | AND | NOT | EQ | NEQ | GT | LT | GEQ | LEQ | BOR | BAND | BXOR | TWIDDLE | MUL | DIV | PLUS | MINUS | MOD | TERN_IF | COLON | QUOTE | DQUOTE | STRING | SYMBOL | DOLLARSYM | WS )
- int alt28=39;
+ // dd/grammar/ECAToken.g:1:8: ( NUMBER | BIND | IF | DO | RULE | CLASS | METHOD | LINE | ENDRULE | NOTHING | TRUE | FALSE | LPAREN | RPAREN | LSQUARE | RSQUARE | LBRACE | RBRACE | SEPR | DOT | ASSIGN | OR | AND | NOT | EQ | NEQ | GT | LT | GEQ | LEQ | BOR | BAND | BXOR | TWIDDLE | MUL | DIV | PLUS | MINUS | MOD | TERN_IF | COLON | QUOTE | DQUOTE | STRING | SYMBOL | DOLLARSYM | WS )
+ int alt30=47;
switch ( input.LA(1) ) {
case '+':
{
- int LA28_1 = input.LA(2);
+ int LA30_1 = input.LA(2);
- if ( ((LA28_1>='0' && LA28_1<='9')) ) {
- alt28=1;
+ if ( ((LA30_1>='0' && LA30_1<='9')) ) {
+ alt30=1;
}
else {
- alt28=29;}
+ alt30=37;}
}
break;
case '0':
@@ -2103,53 +2317,53 @@
case '8':
case '9':
{
- alt28=1;
+ alt30=1;
}
break;
case 'B':
{
- int LA28_3 = input.LA(2);
+ int LA30_3 = input.LA(2);
- if ( (LA28_3=='I') ) {
- int LA28_53 = input.LA(3);
+ if ( (LA30_3=='I') ) {
+ int LA30_57 = input.LA(3);
- if ( (LA28_53=='N') ) {
- int LA28_100 = input.LA(4);
+ if ( (LA30_57=='N') ) {
+ int LA30_112 = input.LA(4);
- if ( (LA28_100=='D') ) {
- int LA28_123 = input.LA(5);
+ if ( (LA30_112=='D') ) {
+ int LA30_143 = input.LA(5);
- if ( (LA28_123=='.'||(LA28_123>='0' && LA28_123<='9')||(LA28_123>='A' && LA28_123<='Z')||LA28_123=='_'||(LA28_123>='a' && LA28_123<='z')) ) {
- alt28=37;
+ if ( (LA30_143=='.'||(LA30_143>='0' && LA30_143<='9')||(LA30_143>='A' && LA30_143<='Z')||LA30_143=='_'||(LA30_143>='a' && LA30_143<='z')) ) {
+ alt30=45;
}
else {
- alt28=2;}
+ alt30=2;}
}
else {
- alt28=37;}
+ alt30=45;}
}
else {
- alt28=37;}
+ alt30=45;}
}
else {
- alt28=37;}
+ alt30=45;}
}
break;
case 'I':
{
- int LA28_4 = input.LA(2);
+ int LA30_4 = input.LA(2);
- if ( (LA28_4=='F') ) {
- int LA28_54 = input.LA(3);
+ if ( (LA30_4=='F') ) {
+ int LA30_58 = input.LA(3);
- if ( (LA28_54=='.'||(LA28_54>='0' && LA28_54<='9')||(LA28_54>='A' && LA28_54<='Z')||LA28_54=='_'||(LA28_54>='a' && LA28_54<='z')) ) {
- alt28=37;
+ if ( (LA30_58=='.'||(LA30_58>='0' && LA30_58<='9')||(LA30_58>='A' && LA30_58<='Z')||LA30_58=='_'||(LA30_58>='a' && LA30_58<='z')) ) {
+ alt30=45;
}
else {
- alt28=3;}
+ alt30=3;}
}
else {
- alt28=37;}
+ alt30=45;}
}
break;
case 'D':
@@ -2157,863 +2371,1219 @@
switch ( input.LA(2) ) {
case 'O':
{
- int LA28_55 = input.LA(3);
+ int LA30_59 = input.LA(3);
- if ( (LA28_55=='.'||(LA28_55>='0' && LA28_55<='9')||(LA28_55>='A' && LA28_55<='Z')||LA28_55=='_'||(LA28_55>='a' && LA28_55<='z')) ) {
- alt28=37;
+ if ( (LA30_59=='.'||(LA30_59>='0' && LA30_59<='9')||(LA30_59>='A' && LA30_59<='Z')||LA30_59=='_'||(LA30_59>='a' && LA30_59<='z')) ) {
+ alt30=45;
}
else {
- alt28=4;}
+ alt30=4;}
}
break;
case 'I':
{
- int LA28_56 = input.LA(3);
+ int LA30_60 = input.LA(3);
- if ( (LA28_56=='V') ) {
- int LA28_103 = input.LA(4);
+ if ( (LA30_60=='V') ) {
+ int LA30_115 = input.LA(4);
- if ( (LA28_103=='I') ) {
- int LA28_124 = input.LA(5);
+ if ( (LA30_115=='I') ) {
+ int LA30_144 = input.LA(5);
- if ( (LA28_124=='D') ) {
- int LA28_133 = input.LA(6);
+ if ( (LA30_144=='D') ) {
+ int LA30_163 = input.LA(6);
- if ( (LA28_133=='E') ) {
- int LA28_139 = input.LA(7);
+ if ( (LA30_163=='E') ) {
+ int LA30_178 = input.LA(7);
- if ( (LA28_139=='.'||(LA28_139>='0' && LA28_139<='9')||(LA28_139>='A' && LA28_139<='Z')||LA28_139=='_'||(LA28_139>='a' && LA28_139<='z')) ) {
- alt28=37;
+ if ( (LA30_178=='.'||(LA30_178>='0' && LA30_178<='9')||(LA30_178>='A' && LA30_178<='Z')||LA30_178=='_'||(LA30_178>='a' && LA30_178<='z')) ) {
+ alt30=45;
}
else {
- alt28=28;}
+ alt30=36;}
}
else {
- alt28=37;}
+ alt30=45;}
}
else {
- alt28=37;}
+ alt30=45;}
}
else {
- alt28=37;}
+ alt30=45;}
}
else {
- alt28=37;}
+ alt30=45;}
}
break;
default:
- alt28=37;}
+ alt30=45;}
}
break;
+ case 'R':
+ {
+ int LA30_6 = input.LA(2);
+
+ if ( (LA30_6=='U') ) {
+ int LA30_61 = input.LA(3);
+
+ if ( (LA30_61=='L') ) {
+ int LA30_116 = input.LA(4);
+
+ if ( (LA30_116=='E') ) {
+ int LA30_145 = input.LA(5);
+
+ if ( (LA30_145=='.'||(LA30_145>='0' && LA30_145<='9')||(LA30_145>='A' && LA30_145<='Z')||LA30_145=='_'||(LA30_145>='a' && LA30_145<='z')) ) {
+ alt30=45;
+ }
+ else {
+ alt30=5;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ break;
+ case 'C':
+ {
+ int LA30_7 = input.LA(2);
+
+ if ( (LA30_7=='L') ) {
+ int LA30_62 = input.LA(3);
+
+ if ( (LA30_62=='A') ) {
+ int LA30_117 = input.LA(4);
+
+ if ( (LA30_117=='S') ) {
+ int LA30_146 = input.LA(5);
+
+ if ( (LA30_146=='S') ) {
+ int LA30_165 = input.LA(6);
+
+ if ( (LA30_165=='.'||(LA30_165>='0' && LA30_165<='9')||(LA30_165>='A' && LA30_165<='Z')||LA30_165=='_'||(LA30_165>='a' && LA30_165<='z')) ) {
+ alt30=45;
+ }
+ else {
+ alt30=6;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ break;
+ case 'M':
+ {
+ switch ( input.LA(2) ) {
+ case 'I':
+ {
+ int LA30_63 = input.LA(3);
+
+ if ( (LA30_63=='N') ) {
+ int LA30_118 = input.LA(4);
+
+ if ( (LA30_118=='U') ) {
+ int LA30_147 = input.LA(5);
+
+ if ( (LA30_147=='S') ) {
+ int LA30_166 = input.LA(6);
+
+ if ( (LA30_166=='.'||(LA30_166>='0' && LA30_166<='9')||(LA30_166>='A' && LA30_166<='Z')||LA30_166=='_'||(LA30_166>='a' && LA30_166<='z')) ) {
+ alt30=45;
+ }
+ else {
+ alt30=38;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ break;
+ case 'E':
+ {
+ int LA30_64 = input.LA(3);
+
+ if ( (LA30_64=='T') ) {
+ int LA30_119 = input.LA(4);
+
+ if ( (LA30_119=='H') ) {
+ int LA30_148 = input.LA(5);
+
+ if ( (LA30_148=='O') ) {
+ int LA30_167 = input.LA(6);
+
+ if ( (LA30_167=='D') ) {
+ int LA30_180 = input.LA(7);
+
+ if ( (LA30_180=='.'||(LA30_180>='0' && LA30_180<='9')||(LA30_180>='A' && LA30_180<='Z')||LA30_180=='_'||(LA30_180>='a' && LA30_180<='z')) ) {
+ alt30=45;
+ }
+ else {
+ alt30=7;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ break;
+ case 'O':
+ {
+ int LA30_65 = input.LA(3);
+
+ if ( (LA30_65=='D') ) {
+ int LA30_120 = input.LA(4);
+
+ if ( (LA30_120=='.'||(LA30_120>='0' && LA30_120<='9')||(LA30_120>='A' && LA30_120<='Z')||LA30_120=='_'||(LA30_120>='a' && LA30_120<='z')) ) {
+ alt30=45;
+ }
+ else {
+ alt30=39;}
+ }
+ else {
+ alt30=45;}
+ }
+ break;
+ default:
+ alt30=45;}
+
+ }
+ break;
+ case 'L':
+ {
+ switch ( input.LA(2) ) {
+ case 'T':
+ {
+ int LA30_66 = input.LA(3);
+
+ if ( (LA30_66=='.'||(LA30_66>='0' && LA30_66<='9')||(LA30_66>='A' && LA30_66<='Z')||LA30_66=='_'||(LA30_66>='a' && LA30_66<='z')) ) {
+ alt30=45;
+ }
+ else {
+ alt30=28;}
+ }
+ break;
+ case 'I':
+ {
+ int LA30_67 = input.LA(3);
+
+ if ( (LA30_67=='N') ) {
+ int LA30_121 = input.LA(4);
+
+ if ( (LA30_121=='E') ) {
+ int LA30_149 = input.LA(5);
+
+ if ( (LA30_149=='.'||(LA30_149>='0' && LA30_149<='9')||(LA30_149>='A' && LA30_149<='Z')||LA30_149=='_'||(LA30_149>='a' && LA30_149<='z')) ) {
+ alt30=45;
+ }
+ else {
+ alt30=8;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ break;
+ case 'E':
+ {
+ int LA30_68 = input.LA(3);
+
+ if ( (LA30_68=='Q') ) {
+ int LA30_122 = input.LA(4);
+
+ if ( (LA30_122=='.'||(LA30_122>='0' && LA30_122<='9')||(LA30_122>='A' && LA30_122<='Z')||LA30_122=='_'||(LA30_122>='a' && LA30_122<='z')) ) {
+ alt30=45;
+ }
+ else {
+ alt30=30;}
+ }
+ else {
+ alt30=45;}
+ }
+ break;
+ default:
+ alt30=45;}
+
+ }
+ break;
+ case 'E':
+ {
+ switch ( input.LA(2) ) {
+ case 'N':
+ {
+ int LA30_69 = input.LA(3);
+
+ if ( (LA30_69=='D') ) {
+ int LA30_123 = input.LA(4);
+
+ if ( (LA30_123=='R') ) {
+ int LA30_150 = input.LA(5);
+
+ if ( (LA30_150=='U') ) {
+ int LA30_169 = input.LA(6);
+
+ if ( (LA30_169=='L') ) {
+ int LA30_181 = input.LA(7);
+
+ if ( (LA30_181=='E') ) {
+ int LA30_186 = input.LA(8);
+
+ if ( (LA30_186=='.'||(LA30_186>='0' && LA30_186<='9')||(LA30_186>='A' && LA30_186<='Z')||LA30_186=='_'||(LA30_186>='a' && LA30_186<='z')) ) {
+ alt30=45;
+ }
+ else {
+ alt30=9;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ break;
+ case 'Q':
+ {
+ int LA30_70 = input.LA(3);
+
+ if ( (LA30_70=='.'||(LA30_70>='0' && LA30_70<='9')||(LA30_70>='A' && LA30_70<='Z')||LA30_70=='_'||(LA30_70>='a' && LA30_70<='z')) ) {
+ alt30=45;
+ }
+ else {
+ alt30=25;}
+ }
+ break;
+ default:
+ alt30=45;}
+
+ }
+ break;
+ case 'N':
+ {
+ switch ( input.LA(2) ) {
+ case 'E':
+ {
+ int LA30_71 = input.LA(3);
+
+ if ( (LA30_71=='Q') ) {
+ int LA30_124 = input.LA(4);
+
+ if ( (LA30_124=='.'||(LA30_124>='0' && LA30_124<='9')||(LA30_124>='A' && LA30_124<='Z')||LA30_124=='_'||(LA30_124>='a' && LA30_124<='z')) ) {
+ alt30=45;
+ }
+ else {
+ alt30=26;}
+ }
+ else {
+ alt30=45;}
+ }
+ break;
+ case 'O':
+ {
+ int LA30_72 = input.LA(3);
+
+ if ( (LA30_72=='T') ) {
+ switch ( input.LA(4) ) {
+ case 'H':
+ {
+ int LA30_151 = input.LA(5);
+
+ if ( (LA30_151=='I') ) {
+ int LA30_170 = input.LA(6);
+
+ if ( (LA30_170=='N') ) {
+ int LA30_182 = input.LA(7);
+
+ if ( (LA30_182=='G') ) {
+ int LA30_187 = input.LA(8);
+
+ if ( (LA30_187=='.'||(LA30_187>='0' && LA30_187<='9')||(LA30_187>='A' && LA30_187<='Z')||LA30_187=='_'||(LA30_187>='a' && LA30_187<='z')) ) {
+ alt30=45;
+ }
+ else {
+ alt30=10;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ break;
+ case '.':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case 'A':
+ case 'B':
+ case 'C':
+ case 'D':
+ case 'E':
+ case 'F':
+ case 'G':
+ case 'I':
+ case 'J':
+ case 'K':
+ case 'L':
+ case 'M':
+ case 'N':
+ case 'O':
+ case 'P':
+ case 'Q':
+ case 'R':
+ case 'S':
+ case 'T':
+ case 'U':
+ case 'V':
+ case 'W':
+ case 'X':
+ case 'Y':
+ case 'Z':
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt30=45;
+ }
+ break;
+ default:
+ alt30=24;}
+
+ }
+ else {
+ alt30=45;}
+ }
+ break;
+ default:
+ alt30=45;}
+
+ }
+ break;
+ case 'T':
+ {
+ switch ( input.LA(2) ) {
+ case 'I':
+ {
+ int LA30_73 = input.LA(3);
+
+ if ( (LA30_73=='M') ) {
+ int LA30_126 = input.LA(4);
+
+ if ( (LA30_126=='E') ) {
+ int LA30_152 = input.LA(5);
+
+ if ( (LA30_152=='S') ) {
+ int LA30_171 = input.LA(6);
+
+ if ( (LA30_171=='.'||(LA30_171>='0' && LA30_171<='9')||(LA30_171>='A' && LA30_171<='Z')||LA30_171=='_'||(LA30_171>='a' && LA30_171<='z')) ) {
+ alt30=45;
+ }
+ else {
+ alt30=35;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ break;
+ case 'R':
+ {
+ int LA30_74 = input.LA(3);
+
+ if ( (LA30_74=='U') ) {
+ int LA30_127 = input.LA(4);
+
+ if ( (LA30_127=='E') ) {
+ int LA30_153 = input.LA(5);
+
+ if ( (LA30_153=='.'||(LA30_153>='0' && LA30_153<='9')||(LA30_153>='A' && LA30_153<='Z')||LA30_153=='_'||(LA30_153>='a' && LA30_153<='z')) ) {
+ alt30=45;
+ }
+ else {
+ alt30=11;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ break;
+ default:
+ alt30=45;}
+
+ }
+ break;
+ case 't':
+ {
+ switch ( input.LA(2) ) {
+ case 'i':
+ {
+ int LA30_75 = input.LA(3);
+
+ if ( (LA30_75=='m') ) {
+ int LA30_128 = input.LA(4);
+
+ if ( (LA30_128=='e') ) {
+ int LA30_154 = input.LA(5);
+
+ if ( (LA30_154=='s') ) {
+ int LA30_173 = input.LA(6);
+
+ if ( (LA30_173=='.'||(LA30_173>='0' && LA30_173<='9')||(LA30_173>='A' && LA30_173<='Z')||LA30_173=='_'||(LA30_173>='a' && LA30_173<='z')) ) {
+ alt30=45;
+ }
+ else {
+ alt30=35;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ break;
+ case 'r':
+ {
+ int LA30_76 = input.LA(3);
+
+ if ( (LA30_76=='u') ) {
+ int LA30_129 = input.LA(4);
+
+ if ( (LA30_129=='e') ) {
+ int LA30_155 = input.LA(5);
+
+ if ( (LA30_155=='.'||(LA30_155>='0' && LA30_155<='9')||(LA30_155>='A' && LA30_155<='Z')||LA30_155=='_'||(LA30_155>='a' && LA30_155<='z')) ) {
+ alt30=45;
+ }
+ else {
+ alt30=11;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ break;
+ default:
+ alt30=45;}
+
+ }
+ break;
+ case 'F':
+ {
+ int LA30_14 = input.LA(2);
+
+ if ( (LA30_14=='A') ) {
+ int LA30_77 = input.LA(3);
+
+ if ( (LA30_77=='L') ) {
+ int LA30_130 = input.LA(4);
+
+ if ( (LA30_130=='S') ) {
+ int LA30_156 = input.LA(5);
+
+ if ( (LA30_156=='E') ) {
+ int LA30_174 = input.LA(6);
+
+ if ( (LA30_174=='.'||(LA30_174>='0' && LA30_174<='9')||(LA30_174>='A' && LA30_174<='Z')||LA30_174=='_'||(LA30_174>='a' && LA30_174<='z')) ) {
+ alt30=45;
+ }
+ else {
+ alt30=12;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ break;
+ case 'f':
+ {
+ int LA30_15 = input.LA(2);
+
+ if ( (LA30_15=='a') ) {
+ int LA30_78 = input.LA(3);
+
+ if ( (LA30_78=='l') ) {
+ int LA30_131 = input.LA(4);
+
+ if ( (LA30_131=='s') ) {
+ int LA30_157 = input.LA(5);
+
+ if ( (LA30_157=='e') ) {
+ int LA30_175 = input.LA(6);
+
+ if ( (LA30_175=='.'||(LA30_175>='0' && LA30_175<='9')||(LA30_175>='A' && LA30_175<='Z')||LA30_175=='_'||(LA30_175>='a' && LA30_175<='z')) ) {
+ alt30=45;
+ }
+ else {
+ alt30=12;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ else {
+ alt30=45;}
+ }
+ break;
case '(':
{
- alt28=5;
+ alt30=13;
}
break;
case ')':
{
- alt28=6;
+ alt30=14;
}
break;
case '[':
{
- alt28=7;
+ alt30=15;
}
break;
case ']':
{
- alt28=8;
+ alt30=16;
}
break;
case '{':
{
- alt28=9;
+ alt30=17;
}
break;
case '}':
{
- alt28=10;
+ alt30=18;
}
break;
case ',':
case ';':
{
- alt28=11;
+ alt30=19;
}
break;
case '.':
{
- alt28=12;
+ alt30=20;
}
break;
case '=':
{
- int LA28_14 = input.LA(2);
+ int LA30_24 = input.LA(2);
- if ( (LA28_14=='=') ) {
- alt28=17;
+ if ( (LA30_24=='=') ) {
+ alt30=25;
}
else {
- alt28=13;}
+ alt30=21;}
}
break;
case '<':
{
switch ( input.LA(2) ) {
- case '=':
+ case '-':
{
- alt28=22;
+ alt30=21;
}
break;
- case '-':
+ case '=':
{
- alt28=13;
+ alt30=30;
}
break;
default:
- alt28=20;}
+ alt30=28;}
}
break;
case '|':
{
- int LA28_16 = input.LA(2);
+ int LA30_26 = input.LA(2);
- if ( (LA28_16=='|') ) {
- alt28=14;
+ if ( (LA30_26=='|') ) {
+ alt30=22;
}
else {
- alt28=23;}
+ alt30=31;}
}
break;
case 'O':
{
- int LA28_17 = input.LA(2);
+ int LA30_27 = input.LA(2);
- if ( (LA28_17=='R') ) {
- int LA28_63 = input.LA(3);
+ if ( (LA30_27=='R') ) {
+ int LA30_85 = input.LA(3);
- if ( (LA28_63=='.'||(LA28_63>='0' && LA28_63<='9')||(LA28_63>='A' && LA28_63<='Z')||LA28_63=='_'||(LA28_63>='a' && LA28_63<='z')) ) {
- alt28=37;
+ if ( (LA30_85=='.'||(LA30_85>='0' && LA30_85<='9')||(LA30_85>='A' && LA30_85<='Z')||LA30_85=='_'||(LA30_85>='a' && LA30_85<='z')) ) {
+ alt30=45;
}
else {
- alt28=14;}
+ alt30=22;}
}
else {
- alt28=37;}
+ alt30=45;}
}
break;
case 'o':
{
- int LA28_18 = input.LA(2);
+ int LA30_28 = input.LA(2);
- if ( (LA28_18=='r') ) {
- int LA28_64 = input.LA(3);
+ if ( (LA30_28=='r') ) {
+ int LA30_86 = input.LA(3);
- if ( (LA28_64=='.'||(LA28_64>='0' && LA28_64<='9')||(LA28_64>='A' && LA28_64<='Z')||LA28_64=='_'||(LA28_64>='a' && LA28_64<='z')) ) {
- alt28=37;
+ if ( (LA30_86=='.'||(LA30_86>='0' && LA30_86<='9')||(LA30_86>='A' && LA30_86<='Z')||LA30_86=='_'||(LA30_86>='a' && LA30_86<='z')) ) {
+ alt30=45;
}
else {
- alt28=14;}
+ alt30=22;}
}
else {
- alt28=37;}
+ alt30=45;}
}
break;
case '&':
{
- int LA28_19 = input.LA(2);
+ int LA30_29 = input.LA(2);
- if ( (LA28_19=='&') ) {
- alt28=15;
+ if ( (LA30_29=='&') ) {
+ alt30=23;
}
else {
- alt28=24;}
+ alt30=32;}
}
break;
case 'A':
{
- int LA28_20 = input.LA(2);
+ int LA30_30 = input.LA(2);
- if ( (LA28_20=='N') ) {
- int LA28_67 = input.LA(3);
+ if ( (LA30_30=='N') ) {
+ int LA30_89 = input.LA(3);
- if ( (LA28_67=='D') ) {
- int LA28_104 = input.LA(4);
+ if ( (LA30_89=='D') ) {
+ int LA30_132 = input.LA(4);
- if ( (LA28_104=='.'||(LA28_104>='0' && LA28_104<='9')||(LA28_104>='A' && LA28_104<='Z')||LA28_104=='_'||(LA28_104>='a' && LA28_104<='z')) ) {
- alt28=37;
+ if ( (LA30_132=='.'||(LA30_132>='0' && LA30_132<='9')||(LA30_132>='A' && LA30_132<='Z')||LA30_132=='_'||(LA30_132>='a' && LA30_132<='z')) ) {
+ alt30=45;
}
else {
- alt28=15;}
+ alt30=23;}
}
else {
- alt28=37;}
+ alt30=45;}
}
else {
- alt28=37;}
+ alt30=45;}
}
break;
case 'a':
{
- int LA28_21 = input.LA(2);
+ int LA30_31 = input.LA(2);
- if ( (LA28_21=='n') ) {
- int LA28_68 = input.LA(3);
+ if ( (LA30_31=='n') ) {
+ int LA30_90 = input.LA(3);
- if ( (LA28_68=='d') ) {
- int LA28_105 = input.LA(4);
+ if ( (LA30_90=='d') ) {
+ int LA30_133 = input.LA(4);
- if ( (LA28_105=='.'||(LA28_105>='0' && LA28_105<='9')||(LA28_105>='A' && LA28_105<='Z')||LA28_105=='_'||(LA28_105>='a' && LA28_105<='z')) ) {
- alt28=37;
+ if ( (LA30_133=='.'||(LA30_133>='0' && LA30_133<='9')||(LA30_133>='A' && LA30_133<='Z')||LA30_133=='_'||(LA30_133>='a' && LA30_133<='z')) ) {
+ alt30=45;
}
else {
- alt28=15;}
+ alt30=23;}
}
else {
- alt28=37;}
+ alt30=45;}
}
else {
- alt28=37;}
+ alt30=45;}
}
break;
case '!':
{
- int LA28_22 = input.LA(2);
+ int LA30_32 = input.LA(2);
- if ( (LA28_22=='=') ) {
- alt28=18;
+ if ( (LA30_32=='=') ) {
+ alt30=26;
}
else {
- alt28=16;}
+ alt30=24;}
}
break;
- case 'N':
+ case 'n':
{
switch ( input.LA(2) ) {
- case 'E':
+ case 'o':
{
- int LA28_71 = input.LA(3);
+ int LA30_93 = input.LA(3);
- if ( (LA28_71=='Q') ) {
- int LA28_106 = input.LA(4);
+ if ( (LA30_93=='t') ) {
+ int LA30_134 = input.LA(4);
- if ( (LA28_106=='.'||(LA28_106>='0' && LA28_106<='9')||(LA28_106>='A' && LA28_106<='Z')||LA28_106=='_'||(LA28_106>='a' && LA28_106<='z')) ) {
- alt28=37;
+ if ( (LA30_134=='.'||(LA30_134>='0' && LA30_134<='9')||(LA30_134>='A' && LA30_134<='Z')||LA30_134=='_'||(LA30_134>='a' && LA30_134<='z')) ) {
+ alt30=45;
}
else {
- alt28=18;}
+ alt30=24;}
}
else {
- alt28=37;}
+ alt30=45;}
}
break;
- case 'O':
- {
- int LA28_72 = input.LA(3);
-
- if ( (LA28_72=='T') ) {
- int LA28_107 = input.LA(4);
-
- if ( (LA28_107=='.'||(LA28_107>='0' && LA28_107<='9')||(LA28_107>='A' && LA28_107<='Z')||LA28_107=='_'||(LA28_107>='a' && LA28_107<='z')) ) {
- alt28=37;
- }
- else {
- alt28=16;}
- }
- else {
- alt28=37;}
- }
- break;
- default:
- alt28=37;}
-
- }
- break;
- case 'n':
- {
- switch ( input.LA(2) ) {
case 'e':
{
- int LA28_73 = input.LA(3);
+ int LA30_94 = input.LA(3);
- if ( (LA28_73=='q') ) {
- int LA28_108 = input.LA(4);
+ if ( (LA30_94=='q') ) {
+ int LA30_135 = input.LA(4);
- if ( (LA28_108=='.'||(LA28_108>='0' && LA28_108<='9')||(LA28_108>='A' && LA28_108<='Z')||LA28_108=='_'||(LA28_108>='a' && LA28_108<='z')) ) {
- alt28=37;
+ if ( (LA30_135=='.'||(LA30_135>='0' && LA30_135<='9')||(LA30_135>='A' && LA30_135<='Z')||LA30_135=='_'||(LA30_135>='a' && LA30_135<='z')) ) {
+ alt30=45;
}
else {
- alt28=18;}
+ alt30=26;}
}
else {
- alt28=37;}
+ alt30=45;}
}
break;
- case 'o':
- {
- int LA28_74 = input.LA(3);
-
- if ( (LA28_74=='t') ) {
- int LA28_109 = input.LA(4);
-
- if ( (LA28_109=='.'||(LA28_109>='0' && LA28_109<='9')||(LA28_109>='A' && LA28_109<='Z')||LA28_109=='_'||(LA28_109>='a' && LA28_109<='z')) ) {
- alt28=37;
- }
- else {
- alt28=16;}
- }
- else {
- alt28=37;}
- }
- break;
default:
- alt28=37;}
+ alt30=45;}
}
break;
- case 'E':
- {
- int LA28_25 = input.LA(2);
-
- if ( (LA28_25=='Q') ) {
- int LA28_75 = input.LA(3);
-
- if ( (LA28_75=='.'||(LA28_75>='0' && LA28_75<='9')||(LA28_75>='A' && LA28_75<='Z')||LA28_75=='_'||(LA28_75>='a' && LA28_75<='z')) ) {
- alt28=37;
- }
- else {
- alt28=17;}
- }
- else {
- alt28=37;}
- }
- break;
case 'e':
{
- int LA28_26 = input.LA(2);
+ int LA30_34 = input.LA(2);
- if ( (LA28_26=='q') ) {
- int LA28_76 = input.LA(3);
+ if ( (LA30_34=='q') ) {
+ int LA30_95 = input.LA(3);
- if ( (LA28_76=='.'||(LA28_76>='0' && LA28_76<='9')||(LA28_76>='A' && LA28_76<='Z')||LA28_76=='_'||(LA28_76>='a' && LA28_76<='z')) ) {
- alt28=37;
+ if ( (LA30_95=='.'||(LA30_95>='0' && LA30_95<='9')||(LA30_95>='A' && LA30_95<='Z')||LA30_95=='_'||(LA30_95>='a' && LA30_95<='z')) ) {
+ alt30=45;
}
else {
- alt28=17;}
+ alt30=25;}
}
else {
- alt28=37;}
+ alt30=45;}
}
break;
case '>':
{
- int LA28_27 = input.LA(2);
+ int LA30_35 = input.LA(2);
- if ( (LA28_27=='=') ) {
- alt28=21;
+ if ( (LA30_35=='=') ) {
+ alt30=29;
}
else {
- alt28=19;}
+ alt30=27;}
}
break;
case 'G':
{
- switch ( input.LA(2) ) {
- case 'T':
- {
- int LA28_79 = input.LA(3);
+ int LA30_36 = input.LA(2);
- if ( (LA28_79=='.'||(LA28_79>='0' && LA28_79<='9')||(LA28_79>='A' && LA28_79<='Z')||LA28_79=='_'||(LA28_79>='a' && LA28_79<='z')) ) {
- alt28=37;
- }
- else {
- alt28=19;}
- }
- break;
- case 'E':
- {
- int LA28_80 = input.LA(3);
+ if ( (LA30_36=='T') ) {
+ int LA30_98 = input.LA(3);
- if ( (LA28_80=='Q') ) {
- int LA28_110 = input.LA(4);
-
- if ( (LA28_110=='.'||(LA28_110>='0' && LA28_110<='9')||(LA28_110>='A' && LA28_110<='Z')||LA28_110=='_'||(LA28_110>='a' && LA28_110<='z')) ) {
- alt28=37;
- }
- else {
- alt28=21;}
+ if ( (LA30_98=='.'||(LA30_98>='0' && LA30_98<='9')||(LA30_98>='A' && LA30_98<='Z')||LA30_98=='_'||(LA30_98>='a' && LA30_98<='z')) ) {
+ alt30=45;
}
else {
- alt28=37;}
- }
- break;
- default:
- alt28=37;}
-
+ alt30=27;}
}
+ else {
+ alt30=45;}
+ }
break;
case 'g':
{
switch ( input.LA(2) ) {
- case 't':
- {
- int LA28_81 = input.LA(3);
-
- if ( (LA28_81=='.'||(LA28_81>='0' && LA28_81<='9')||(LA28_81>='A' && LA28_81<='Z')||LA28_81=='_'||(LA28_81>='a' && LA28_81<='z')) ) {
- alt28=37;
- }
- else {
- alt28=19;}
- }
- break;
case 'e':
{
- int LA28_82 = input.LA(3);
+ int LA30_99 = input.LA(3);
- if ( (LA28_82=='q') ) {
- int LA28_111 = input.LA(4);
+ if ( (LA30_99=='q') ) {
+ int LA30_136 = input.LA(4);
- if ( (LA28_111=='.'||(LA28_111>='0' && LA28_111<='9')||(LA28_111>='A' && LA28_111<='Z')||LA28_111=='_'||(LA28_111>='a' && LA28_111<='z')) ) {
- alt28=37;
+ if ( (LA30_136=='.'||(LA30_136>='0' && LA30_136<='9')||(LA30_136>='A' && LA30_136<='Z')||LA30_136=='_'||(LA30_136>='a' && LA30_136<='z')) ) {
+ alt30=45;
}
else {
- alt28=21;}
+ alt30=29;}
}
else {
- alt28=37;}
+ alt30=45;}
}
break;
- default:
- alt28=37;}
-
- }
- break;
- case 'L':
- {
- switch ( input.LA(2) ) {
- case 'E':
+ case 't':
{
- int LA28_83 = input.LA(3);
+ int LA30_100 = input.LA(3);
- if ( (LA28_83=='Q') ) {
- int LA28_112 = input.LA(4);
-
- if ( (LA28_112=='.'||(LA28_112>='0' && LA28_112<='9')||(LA28_112>='A' && LA28_112<='Z')||LA28_112=='_'||(LA28_112>='a' && LA28_112<='z')) ) {
- alt28=37;
- }
- else {
- alt28=22;}
+ if ( (LA30_100=='.'||(LA30_100>='0' && LA30_100<='9')||(LA30_100>='A' && LA30_100<='Z')||LA30_100=='_'||(LA30_100>='a' && LA30_100<='z')) ) {
+ alt30=45;
}
else {
- alt28=37;}
+ alt30=27;}
}
break;
- case 'T':
- {
- int LA28_84 = input.LA(3);
-
- if ( (LA28_84=='.'||(LA28_84>='0' && LA28_84<='9')||(LA28_84>='A' && LA28_84<='Z')||LA28_84=='_'||(LA28_84>='a' && LA28_84<='z')) ) {
- alt28=37;
- }
- else {
- alt28=20;}
- }
- break;
default:
- alt28=37;}
+ alt30=45;}
}
break;
case 'l':
{
switch ( input.LA(2) ) {
- case 'e':
+ case 't':
{
- int LA28_85 = input.LA(3);
+ int LA30_101 = input.LA(3);
- if ( (LA28_85=='q') ) {
- int LA28_113 = input.LA(4);
-
- if ( (LA28_113=='.'||(LA28_113>='0' && LA28_113<='9')||(LA28_113>='A' && LA28_113<='Z')||LA28_113=='_'||(LA28_113>='a' && LA28_113<='z')) ) {
- alt28=37;
- }
- else {
- alt28=22;}
+ if ( (LA30_101=='.'||(LA30_101>='0' && LA30_101<='9')||(LA30_101>='A' && LA30_101<='Z')||LA30_101=='_'||(LA30_101>='a' && LA30_101<='z')) ) {
+ alt30=45;
}
else {
- alt28=37;}
+ alt30=28;}
}
break;
- case 't':
+ case 'e':
{
- int LA28_86 = input.LA(3);
+ int LA30_102 = input.LA(3);
- if ( (LA28_86=='.'||(LA28_86>='0' && LA28_86<='9')||(LA28_86>='A' && LA28_86<='Z')||LA28_86=='_'||(LA28_86>='a' && LA28_86<='z')) ) {
- alt28=37;
+ if ( (LA30_102=='q') ) {
+ int LA30_137 = input.LA(4);
+
+ if ( (LA30_137=='.'||(LA30_137>='0' && LA30_137<='9')||(LA30_137>='A' && LA30_137<='Z')||LA30_137=='_'||(LA30_137>='a' && LA30_137<='z')) ) {
+ alt30=45;
+ }
+ else {
+ alt30=30;}
}
else {
- alt28=20;}
+ alt30=45;}
}
break;
default:
- alt28=37;}
+ alt30=45;}
}
break;
case '^':
{
- alt28=25;
+ alt30=33;
}
break;
case '~':
{
- alt28=26;
+ alt30=34;
}
break;
case '*':
{
- alt28=27;
+ alt30=35;
}
break;
- case 'T':
- {
- int LA28_35 = input.LA(2);
-
- if ( (LA28_35=='I') ) {
- int LA28_87 = input.LA(3);
-
- if ( (LA28_87=='M') ) {
- int LA28_114 = input.LA(4);
-
- if ( (LA28_114=='E') ) {
- int LA28_125 = input.LA(5);
-
- if ( (LA28_125=='S') ) {
- int LA28_134 = input.LA(6);
-
- if ( (LA28_134=='.'||(LA28_134>='0' && LA28_134<='9')||(LA28_134>='A' && LA28_134<='Z')||LA28_134=='_'||(LA28_134>='a' && LA28_134<='z')) ) {
- alt28=37;
- }
- else {
- alt28=27;}
- }
- else {
- alt28=37;}
- }
- else {
- alt28=37;}
- }
- else {
- alt28=37;}
- }
- else {
- alt28=37;}
- }
- break;
- case 't':
- {
- int LA28_36 = input.LA(2);
-
- if ( (LA28_36=='i') ) {
- int LA28_88 = input.LA(3);
-
- if ( (LA28_88=='m') ) {
- int LA28_115 = input.LA(4);
-
- if ( (LA28_115=='e') ) {
- int LA28_126 = input.LA(5);
-
- if ( (LA28_126=='s') ) {
- int LA28_135 = input.LA(6);
-
- if ( (LA28_135=='.'||(LA28_135>='0' && LA28_135<='9')||(LA28_135>='A' && LA28_135<='Z')||LA28_135=='_'||(LA28_135>='a' && LA28_135<='z')) ) {
- alt28=37;
- }
- else {
- alt28=27;}
- }
- else {
- alt28=37;}
- }
- else {
- alt28=37;}
- }
- else {
- alt28=37;}
- }
- else {
- alt28=37;}
- }
- break;
case '/':
{
- alt28=28;
+ alt30=36;
}
break;
case 'd':
{
- int LA28_38 = input.LA(2);
+ int LA30_43 = input.LA(2);
- if ( (LA28_38=='i') ) {
- int LA28_89 = input.LA(3);
+ if ( (LA30_43=='i') ) {
+ int LA30_103 = input.LA(3);
- if ( (LA28_89=='v') ) {
- int LA28_116 = input.LA(4);
+ if ( (LA30_103=='v') ) {
+ int LA30_138 = input.LA(4);
- if ( (LA28_116=='i') ) {
- int LA28_127 = input.LA(5);
+ if ( (LA30_138=='i') ) {
+ int LA30_158 = input.LA(5);
- if ( (LA28_127=='d') ) {
- int LA28_136 = input.LA(6);
+ if ( (LA30_158=='d') ) {
+ int LA30_176 = input.LA(6);
- if ( (LA28_136=='e') ) {
- int LA28_140 = input.LA(7);
+ if ( (LA30_176=='e') ) {
+ int LA30_184 = input.LA(7);
- if ( (LA28_140=='.'||(LA28_140>='0' && LA28_140<='9')||(LA28_140>='A' && LA28_140<='Z')||LA28_140=='_'||(LA28_140>='a' && LA28_140<='z')) ) {
- alt28=37;
+ if ( (LA30_184=='.'||(LA30_184>='0' && LA30_184<='9')||(LA30_184>='A' && LA30_184<='Z')||LA30_184=='_'||(LA30_184>='a' && LA30_184<='z')) ) {
+ alt30=45;
}
else {
- alt28=28;}
+ alt30=36;}
}
else {
- alt28=37;}
+ alt30=45;}
}
else {
- alt28=37;}
+ alt30=45;}
}
else {
- alt28=37;}
+ alt30=45;}
}
else {
- alt28=37;}
+ alt30=45;}
}
else {
- alt28=37;}
+ alt30=45;}
}
break;
case '-':
{
- int LA28_39 = input.LA(2);
+ int LA30_44 = input.LA(2);
- if ( ((LA28_39>='0' && LA28_39<='9')) ) {
- alt28=1;
+ if ( ((LA30_44>='0' && LA30_44<='9')) ) {
+ alt30=1;
}
else {
- alt28=30;}
+ alt30=38;}
}
break;
case 'P':
{
- int LA28_40 = input.LA(2);
+ int LA30_45 = input.LA(2);
- if ( (LA28_40=='L') ) {
- int LA28_91 = input.LA(3);
+ if ( (LA30_45=='L') ) {
+ int LA30_105 = input.LA(3);
- if ( (LA28_91=='U') ) {
- int LA28_117 = input.LA(4);
+ if ( (LA30_105=='U') ) {
+ int LA30_139 = input.LA(4);
- if ( (LA28_117=='S') ) {
- int LA28_128 = input.LA(5);
+ if ( (LA30_139=='S') ) {
+ int LA30_159 = input.LA(5);
- if ( (LA28_128=='.'||(LA28_128>='0' && LA28_128<='9')||(LA28_128>='A' && LA28_128<='Z')||LA28_128=='_'||(LA28_128>='a' && LA28_128<='z')) ) {
- alt28=37;
+ if ( (LA30_159=='.'||(LA30_159>='0' && LA30_159<='9')||(LA30_159>='A' && LA30_159<='Z')||LA30_159=='_'||(LA30_159>='a' && LA30_159<='z')) ) {
+ alt30=45;
}
else {
- alt28=29;}
+ alt30=37;}
}
else {
- alt28=37;}
+ alt30=45;}
}
else {
- alt28=37;}
+ alt30=45;}
}
else {
- alt28=37;}
+ alt30=45;}
}
break;
case 'p':
{
- int LA28_41 = input.LA(2);
+ int LA30_46 = input.LA(2);
- if ( (LA28_41=='l') ) {
- int LA28_92 = input.LA(3);
+ if ( (LA30_46=='l') ) {
+ int LA30_106 = input.LA(3);
- if ( (LA28_92=='u') ) {
- int LA28_118 = input.LA(4);
+ if ( (LA30_106=='u') ) {
+ int LA30_140 = input.LA(4);
- if ( (LA28_118=='s') ) {
- int LA28_129 = input.LA(5);
+ if ( (LA30_140=='s') ) {
+ int LA30_160 = input.LA(5);
- if ( (LA28_129=='.'||(LA28_129>='0' && LA28_129<='9')||(LA28_129>='A' && LA28_129<='Z')||LA28_129=='_'||(LA28_129>='a' && LA28_129<='z')) ) {
- alt28=37;
+ if ( (LA30_160=='.'||(LA30_160>='0' && LA30_160<='9')||(LA30_160>='A' && LA30_160<='Z')||LA30_160=='_'||(LA30_160>='a' && LA30_160<='z')) ) {
+ alt30=45;
}
else {
- alt28=29;}
+ alt30=37;}
}
else {
- alt28=37;}
+ alt30=45;}
}
else {
- alt28=37;}
+ alt30=45;}
}
else {
- alt28=37;}
+ alt30=45;}
}
break;
- case 'M':
+ case 'm':
{
switch ( input.LA(2) ) {
- case 'O':
+ case 'i':
{
- int LA28_93 = input.LA(3);
+ int LA30_107 = input.LA(3);
- if ( (LA28_93=='D') ) {
- int LA28_119 = input.LA(4);
+ if ( (LA30_107=='n') ) {
+ int LA30_141 = input.LA(4);
- if ( (LA28_119=='.'||(LA28_119>='0' && LA28_119<='9')||(LA28_119>='A' && LA28_119<='Z')||LA28_119=='_'||(LA28_119>='a' && LA28_119<='z')) ) {
- alt28=37;
- }
- else {
- alt28=31;}
- }
- else {
- alt28=37;}
- }
- break;
- case 'I':
- {
- int LA28_94 = input.LA(3);
+ if ( (LA30_141=='u') ) {
+ int LA30_161 = input.LA(5);
- if ( (LA28_94=='N') ) {
- int LA28_120 = input.LA(4);
+ if ( (LA30_161=='s') ) {
+ int LA30_177 = input.LA(6);
- if ( (LA28_120=='U') ) {
- int LA28_130 = input.LA(5);
-
- if ( (LA28_130=='S') ) {
- int LA28_137 = input.LA(6);
-
- if ( (LA28_137=='.'||(LA28_137>='0' && LA28_137<='9')||(LA28_137>='A' && LA28_137<='Z')||LA28_137=='_'||(LA28_137>='a' && LA28_137<='z')) ) {
- alt28=37;
+ if ( (LA30_177=='.'||(LA30_177>='0' && LA30_177<='9')||(LA30_177>='A' && LA30_177<='Z')||LA30_177=='_'||(LA30_177>='a' && LA30_177<='z')) ) {
+ alt30=45;
}
else {
- alt28=30;}
+ alt30=38;}
}
else {
- alt28=37;}
+ alt30=45;}
}
else {
- alt28=37;}
+ alt30=45;}
}
else {
- alt28=37;}
+ alt30=45;}
}
break;
- default:
- alt28=37;}
-
- }
- break;
- case 'm':
- {
- switch ( input.LA(2) ) {
case 'o':
{
- int LA28_95 = input.LA(3);
+ int LA30_108 = input.LA(3);
- if ( (LA28_95=='d') ) {
- int LA28_121 = input.LA(4);
+ if ( (LA30_108=='d') ) {
+ int LA30_142 = input.LA(4);
- if ( (LA28_121=='.'||(LA28_121>='0' && LA28_121<='9')||(LA28_121>='A' && LA28_121<='Z')||LA28_121=='_'||(LA28_121>='a' && LA28_121<='z')) ) {
- alt28=37;
+ if ( (LA30_142=='.'||(LA30_142>='0' && LA30_142<='9')||(LA30_142>='A' && LA30_142<='Z')||LA30_142=='_'||(LA30_142>='a' && LA30_142<='z')) ) {
+ alt30=45;
}
else {
- alt28=31;}
+ alt30=39;}
}
else {
- alt28=37;}
+ alt30=45;}
}
break;
- case 'i':
- {
- int LA28_96 = input.LA(3);
-
- if ( (LA28_96=='n') ) {
- int LA28_122 = input.LA(4);
-
- if ( (LA28_122=='u') ) {
- int LA28_131 = input.LA(5);
-
- if ( (LA28_131=='s') ) {
- int LA28_138 = input.LA(6);
-
- if ( (LA28_138=='.'||(LA28_138>='0' && LA28_138<='9')||(LA28_138>='A' && LA28_138<='Z')||LA28_138=='_'||(LA28_138>='a' && LA28_138<='z')) ) {
- alt28=37;
- }
- else {
- alt28=30;}
- }
- else {
- alt28=37;}
- }
- else {
- alt28=37;}
- }
- else {
- alt28=37;}
- }
- break;
default:
- alt28=37;}
+ alt30=45;}
}
break;
case '%':
{
- alt28=31;
+ alt30=39;
}
break;
case '?':
{
- alt28=32;
+ alt30=40;
}
break;
case ':':
{
- alt28=33;
+ alt30=41;
}
break;
case '\'':
{
- int LA28_47 = input.LA(2);
+ int LA30_51 = input.LA(2);
- if ( ((LA28_47>='!' && LA28_47<='~')) ) {
- alt28=37;
+ if ( (LA30_51=='\t'||LA30_51=='\r'||(LA30_51>=' ' && LA30_51<='~')) ) {
+ alt30=45;
}
else {
- alt28=34;}
+ alt30=42;}
}
break;
case '\"':
{
- int LA28_48 = input.LA(2);
+ int LA30_52 = input.LA(2);
- if ( (LA28_48=='\t'||LA28_48=='\r'||(LA28_48>=' ' && LA28_48<='~')) ) {
- alt28=36;
+ if ( (LA30_52=='\t'||LA30_52=='\r'||(LA30_52>=' ' && LA30_52<='~')) ) {
+ alt30=44;
}
else {
- alt28=35;}
+ alt30=43;}
}
break;
- case 'C':
- case 'F':
case 'H':
case 'J':
case 'K':
case 'Q':
- case 'R':
case 'S':
case 'U':
case 'V':
@@ -3024,7 +3594,6 @@
case '_':
case 'b':
case 'c':
- case 'f':
case 'h':
case 'i':
case 'j':
@@ -3039,12 +3608,12 @@
case 'y':
case 'z':
{
- alt28=37;
+ alt30=45;
}
break;
case '$':
{
- alt28=38;
+ alt30=46;
}
break;
case '\t':
@@ -3052,17 +3621,17 @@
case '\r':
case ' ':
{
- alt28=39;
+ alt30=47;
}
break;
default:
NoViableAltException nvae =
- new NoViableAltException("1:1: Tokens : ( NUMBER | BIND | IF | DO | LPAREN | RPAREN | LSQUARE | RSQUARE | LBRACE | RBRACE | SEPR | DOT | ASSIGN | OR | AND | NOT | EQ | NEQ | GT | LT | GEQ | LEQ | BOR | BAND | BXOR | TWIDDLE | MUL | DIV | PLUS | MINUS | MOD | TERN_IF | COLON | QUOTE | DQUOTE | STRING | SYMBOL | DOLLARSYM | WS );", 28, 0, input);
+ new NoViableAltException("1:1: Tokens : ( NUMBER | BIND | IF | DO | RULE | CLASS | METHOD | LINE | ENDRULE | NOTHING | TRUE | FALSE | LPAREN | RPAREN | LSQUARE | RSQUARE | LBRACE | RBRACE | SEPR | DOT | ASSIGN | OR | AND | NOT | EQ | NEQ | GT | LT | GEQ | LEQ | BOR | BAND | BXOR | TWIDDLE | MUL | DIV | PLUS | MINUS | MOD | TERN_IF | COLON | QUOTE | DQUOTE | STRING | SYMBOL | DOLLARSYM | WS );", 30, 0, input);
throw nvae;
}
- switch (alt28) {
+ switch (alt30) {
case 1 :
// dd/grammar/ECAToken.g:1:10: NUMBER
{
@@ -3092,246 +3661,302 @@
}
break;
case 5 :
- // dd/grammar/ECAToken.g:1:28: LPAREN
+ // dd/grammar/ECAToken.g:1:28: RULE
{
- mLPAREN();
+ mRULE();
}
break;
case 6 :
- // dd/grammar/ECAToken.g:1:35: RPAREN
+ // dd/grammar/ECAToken.g:1:33: CLASS
{
- mRPAREN();
+ mCLASS();
}
break;
case 7 :
- // dd/grammar/ECAToken.g:1:42: LSQUARE
+ // dd/grammar/ECAToken.g:1:39: METHOD
{
- mLSQUARE();
+ mMETHOD();
}
break;
case 8 :
- // dd/grammar/ECAToken.g:1:50: RSQUARE
+ // dd/grammar/ECAToken.g:1:46: LINE
{
- mRSQUARE();
+ mLINE();
}
break;
case 9 :
- // dd/grammar/ECAToken.g:1:58: LBRACE
+ // dd/grammar/ECAToken.g:1:51: ENDRULE
{
- mLBRACE();
+ mENDRULE();
}
break;
case 10 :
- // dd/grammar/ECAToken.g:1:65: RBRACE
+ // dd/grammar/ECAToken.g:1:59: NOTHING
{
- mRBRACE();
+ mNOTHING();
}
break;
case 11 :
- // dd/grammar/ECAToken.g:1:72: SEPR
+ // dd/grammar/ECAToken.g:1:67: TRUE
{
- mSEPR();
+ mTRUE();
}
break;
case 12 :
- // dd/grammar/ECAToken.g:1:77: DOT
+ // dd/grammar/ECAToken.g:1:72: FALSE
{
- mDOT();
+ mFALSE();
}
break;
case 13 :
- // dd/grammar/ECAToken.g:1:81: ASSIGN
+ // dd/grammar/ECAToken.g:1:78: LPAREN
{
- mASSIGN();
+ mLPAREN();
}
break;
case 14 :
- // dd/grammar/ECAToken.g:1:88: OR
+ // dd/grammar/ECAToken.g:1:85: RPAREN
{
- mOR();
+ mRPAREN();
}
break;
case 15 :
- // dd/grammar/ECAToken.g:1:91: AND
+ // dd/grammar/ECAToken.g:1:92: LSQUARE
{
- mAND();
+ mLSQUARE();
}
break;
case 16 :
- // dd/grammar/ECAToken.g:1:95: NOT
+ // dd/grammar/ECAToken.g:1:100: RSQUARE
{
- mNOT();
+ mRSQUARE();
}
break;
case 17 :
- // dd/grammar/ECAToken.g:1:99: EQ
+ // dd/grammar/ECAToken.g:1:108: LBRACE
{
- mEQ();
+ mLBRACE();
}
break;
case 18 :
- // dd/grammar/ECAToken.g:1:102: NEQ
+ // dd/grammar/ECAToken.g:1:115: RBRACE
{
- mNEQ();
+ mRBRACE();
}
break;
case 19 :
- // dd/grammar/ECAToken.g:1:106: GT
+ // dd/grammar/ECAToken.g:1:122: SEPR
{
- mGT();
+ mSEPR();
}
break;
case 20 :
- // dd/grammar/ECAToken.g:1:109: LT
+ // dd/grammar/ECAToken.g:1:127: DOT
{
- mLT();
+ mDOT();
}
break;
case 21 :
- // dd/grammar/ECAToken.g:1:112: GEQ
+ // dd/grammar/ECAToken.g:1:131: ASSIGN
{
- mGEQ();
+ mASSIGN();
}
break;
case 22 :
- // dd/grammar/ECAToken.g:1:116: LEQ
+ // dd/grammar/ECAToken.g:1:138: OR
{
- mLEQ();
+ mOR();
}
break;
case 23 :
- // dd/grammar/ECAToken.g:1:120: BOR
+ // dd/grammar/ECAToken.g:1:141: AND
{
- mBOR();
+ mAND();
}
break;
case 24 :
- // dd/grammar/ECAToken.g:1:124: BAND
+ // dd/grammar/ECAToken.g:1:145: NOT
{
- mBAND();
+ mNOT();
}
break;
case 25 :
- // dd/grammar/ECAToken.g:1:129: BXOR
+ // dd/grammar/ECAToken.g:1:149: EQ
{
- mBXOR();
+ mEQ();
}
break;
case 26 :
- // dd/grammar/ECAToken.g:1:134: TWIDDLE
+ // dd/grammar/ECAToken.g:1:152: NEQ
{
- mTWIDDLE();
+ mNEQ();
}
break;
case 27 :
- // dd/grammar/ECAToken.g:1:142: MUL
+ // dd/grammar/ECAToken.g:1:156: GT
{
- mMUL();
+ mGT();
}
break;
case 28 :
- // dd/grammar/ECAToken.g:1:146: DIV
+ // dd/grammar/ECAToken.g:1:159: LT
{
- mDIV();
+ mLT();
}
break;
case 29 :
- // dd/grammar/ECAToken.g:1:150: PLUS
+ // dd/grammar/ECAToken.g:1:162: GEQ
{
- mPLUS();
+ mGEQ();
}
break;
case 30 :
- // dd/grammar/ECAToken.g:1:155: MINUS
+ // dd/grammar/ECAToken.g:1:166: LEQ
{
- mMINUS();
+ mLEQ();
}
break;
case 31 :
- // dd/grammar/ECAToken.g:1:161: MOD
+ // dd/grammar/ECAToken.g:1:170: BOR
{
- mMOD();
+ mBOR();
}
break;
case 32 :
- // dd/grammar/ECAToken.g:1:165: TERN_IF
+ // dd/grammar/ECAToken.g:1:174: BAND
{
- mTERN_IF();
+ mBAND();
}
break;
case 33 :
- // dd/grammar/ECAToken.g:1:173: COLON
+ // dd/grammar/ECAToken.g:1:179: BXOR
{
- mCOLON();
+ mBXOR();
}
break;
case 34 :
- // dd/grammar/ECAToken.g:1:179: QUOTE
+ // dd/grammar/ECAToken.g:1:184: TWIDDLE
{
- mQUOTE();
+ mTWIDDLE();
}
break;
case 35 :
- // dd/grammar/ECAToken.g:1:185: DQUOTE
+ // dd/grammar/ECAToken.g:1:192: MUL
{
- mDQUOTE();
+ mMUL();
}
break;
case 36 :
- // dd/grammar/ECAToken.g:1:192: STRING
+ // dd/grammar/ECAToken.g:1:196: DIV
{
- mSTRING();
+ mDIV();
}
break;
case 37 :
- // dd/grammar/ECAToken.g:1:199: SYMBOL
+ // dd/grammar/ECAToken.g:1:200: PLUS
{
- mSYMBOL();
+ mPLUS();
}
break;
case 38 :
- // dd/grammar/ECAToken.g:1:206: DOLLARSYM
+ // dd/grammar/ECAToken.g:1:205: MINUS
{
- mDOLLARSYM();
+ mMINUS();
}
break;
case 39 :
- // dd/grammar/ECAToken.g:1:216: WS
+ // dd/grammar/ECAToken.g:1:211: MOD
{
+ mMOD();
+
+ }
+ break;
+ case 40 :
+ // dd/grammar/ECAToken.g:1:215: TERN_IF
+ {
+ mTERN_IF();
+
+ }
+ break;
+ case 41 :
+ // dd/grammar/ECAToken.g:1:223: COLON
+ {
+ mCOLON();
+
+ }
+ break;
+ case 42 :
+ // dd/grammar/ECAToken.g:1:229: QUOTE
+ {
+ mQUOTE();
+
+ }
+ break;
+ case 43 :
+ // dd/grammar/ECAToken.g:1:235: DQUOTE
+ {
+ mDQUOTE();
+
+ }
+ break;
+ case 44 :
+ // dd/grammar/ECAToken.g:1:242: STRING
+ {
+ mSTRING();
+
+ }
+ break;
+ case 45 :
+ // dd/grammar/ECAToken.g:1:249: SYMBOL
+ {
+ mSYMBOL();
+
+ }
+ break;
+ case 46 :
+ // dd/grammar/ECAToken.g:1:256: DOLLARSYM
+ {
+ mDOLLARSYM();
+
+ }
+ break;
+ case 47 :
+ // dd/grammar/ECAToken.g:1:266: WS
+ {
mWS();
}
@@ -3343,7 +3968,7 @@
protected DFA6 dfa6 = new DFA6(this);
- protected DFA25 dfa25 = new DFA25(this);
+ protected DFA27 dfa27 = new DFA27(this);
static final String DFA6_eotS =
"\2\uffff\2\4\2\uffff\1\4";
static final String DFA6_eofS =
@@ -3396,22 +4021,22 @@
this.transition = DFA6_transition;
}
public String getDescription() {
- return "42:1: NUMBER : ( INTEGER | FLOAT );";
+ return "41:1: NUMBER : ( INTEGER | FLOAT );";
}
}
- static final String DFA25_eotS =
+ static final String DFA27_eotS =
"\1\uffff\2\3\2\uffff";
- static final String DFA25_eofS =
+ static final String DFA27_eofS =
"\5\uffff";
- static final String DFA25_minS =
+ static final String DFA27_minS =
"\1\101\2\56\2\uffff";
- static final String DFA25_maxS =
+ static final String DFA27_maxS =
"\3\172\2\uffff";
- static final String DFA25_acceptS =
+ static final String DFA27_acceptS =
"\3\uffff\1\2\1\1";
- static final String DFA25_specialS =
+ static final String DFA27_specialS =
"\5\uffff}>";
- static final String[] DFA25_transitionS = {
+ static final String[] DFA27_transitionS = {
"\32\1\4\uffff\1\1\1\uffff\32\1",
"\1\4\1\uffff\12\2\7\uffff\32\2\4\uffff\1\2\1\uffff\32\2",
"\1\4\1\uffff\12\2\7\uffff\32\2\4\uffff\1\2\1\uffff\32\2",
@@ -3419,37 +4044,37 @@
""
};
- static final short[] DFA25_eot = DFA.unpackEncodedString(DFA25_eotS);
- static final short[] DFA25_eof = DFA.unpackEncodedString(DFA25_eofS);
- static final char[] DFA25_min = DFA.unpackEncodedStringToUnsignedChars(DFA25_minS);
- static final char[] DFA25_max = DFA.unpackEncodedStringToUnsignedChars(DFA25_maxS);
- static final short[] DFA25_accept = DFA.unpackEncodedString(DFA25_acceptS);
- static final short[] DFA25_special = DFA.unpackEncodedString(DFA25_specialS);
- static final short[][] DFA25_transition;
+ static final short[] DFA27_eot = DFA.unpackEncodedString(DFA27_eotS);
+ static final short[] DFA27_eof = DFA.unpackEncodedString(DFA27_eofS);
+ static final char[] DFA27_min = DFA.unpackEncodedStringToUnsignedChars(DFA27_minS);
+ static final char[] DFA27_max = DFA.unpackEncodedStringToUnsignedChars(DFA27_maxS);
+ static final short[] DFA27_accept = DFA.unpackEncodedString(DFA27_acceptS);
+ static final short[] DFA27_special = DFA.unpackEncodedString(DFA27_specialS);
+ static final short[][] DFA27_transition;
static {
- int numStates = DFA25_transitionS.length;
- DFA25_transition = new short[numStates][];
+ int numStates = DFA27_transitionS.length;
+ DFA27_transition = new short[numStates][];
for (int i=0; i<numStates; i++) {
- DFA25_transition[i] = DFA.unpackEncodedString(DFA25_transitionS[i]);
+ DFA27_transition[i] = DFA.unpackEncodedString(DFA27_transitionS[i]);
}
}
- class DFA25 extends DFA {
+ class DFA27 extends DFA {
- public DFA25(BaseRecognizer recognizer) {
+ public DFA27(BaseRecognizer recognizer) {
this.recognizer = recognizer;
- this.decisionNumber = 25;
- this.eot = DFA25_eot;
- this.eof = DFA25_eof;
- this.min = DFA25_min;
- this.max = DFA25_max;
- this.accept = DFA25_accept;
- this.special = DFA25_special;
- this.transition = DFA25_transition;
+ this.decisionNumber = 27;
+ this.eot = DFA27_eot;
+ this.eof = DFA27_eof;
+ this.min = DFA27_min;
+ this.max = DFA27_max;
+ this.accept = DFA27_accept;
+ this.special = DFA27_special;
+ this.transition = DFA27_transition;
}
public String getDescription() {
- return "230:1: fragment DOTSYM : ( BARESYM DOT DOTSYM | BARESYM );";
+ return "253:1: fragment DOTSYM : ( BARESYM DOT DOTSYM | BARESYM );";
}
}
More information about the jboss-svn-commits
mailing list