diff options
author | Kristóf Marussy <kristof@marussy.com> | 2021-06-27 23:21:42 +0200 |
---|---|---|
committer | Kristóf Marussy <kristof@marussy.com> | 2021-06-27 23:30:25 +0200 |
commit | 7febe0b4781c5bb0fab34895ad642040ae143a8b (patch) | |
tree | 5bc49f9195b18a938382f2527ee4ab273527a07a /language | |
parent | Electric semicolons (diff) | |
download | refinery-7febe0b4781c5bb0fab34895ad642040ae143a8b.tar.gz refinery-7febe0b4781c5bb0fab34895ad642040ae143a8b.tar.zst refinery-7febe0b4781c5bb0fab34895ad642040ae143a8b.zip |
Add data constant support
Diffstat (limited to 'language')
12 files changed, 4444 insertions, 1300 deletions
diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/Problem.xtext b/language/src/main/java/org/eclipse/viatra/solver/language/Problem.xtext index 466988d8..7e253ef5 100644 --- a/language/src/main/java/org/eclipse/viatra/solver/language/Problem.xtext +++ b/language/src/main/java/org/eclipse/viatra/solver/language/Problem.xtext | |||
@@ -8,7 +8,7 @@ Problem: | |||
8 | statements+=Statement*; | 8 | statements+=Statement*; |
9 | 9 | ||
10 | Statement: | 10 | Statement: |
11 | ClassDeclaration | EnumDeclaration | PredicateDefinition | Assertion | ScopeDeclaration; | 11 | ClassDeclaration | EnumDeclaration | PredicateDefinition | Assertion | NodeValueAssertion | ScopeDeclaration; |
12 | 12 | ||
13 | ClassDeclaration: | 13 | ClassDeclaration: |
14 | abstract?="abstract"? "class" | 14 | abstract?="abstract"? "class" |
@@ -56,23 +56,53 @@ Atom: | |||
56 | "(" (arguments+=Argument ("," arguments+=Argument)*)? ")"; | 56 | "(" (arguments+=Argument ("," arguments+=Argument)*)? ")"; |
57 | 57 | ||
58 | Argument: | 58 | Argument: |
59 | VariableOrNodeArgument | ConstantArgument; | ||
60 | |||
61 | VariableOrNodeArgument: | ||
59 | variableOrNode=[VariableOrNode|QualifiedName]; | 62 | variableOrNode=[VariableOrNode|QualifiedName]; |
60 | 63 | ||
64 | ConstantArgument: | ||
65 | constant=Constant; | ||
66 | |||
61 | Assertion: | 67 | Assertion: |
62 | (relation=[Relation|QualifiedName] | 68 | (relation=[Relation|QualifiedName] |
63 | "(" (arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? ")" | 69 | "(" (arguments+=AssertionArgument ("," arguments+=AssertionArgument)*)? ")" |
64 | ":" value=LogicValue | | 70 | ":" value=LogicValue | |
65 | value=ShortLogicValue? | 71 | value=ShortLogicValue? |
66 | relation=[Relation|QualifiedName] | 72 | relation=[Relation|QualifiedName] |
67 | "(" (arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? ")") | 73 | "(" (arguments+=AssertionArgument ("," arguments+=AssertionArgument)*)? ")") |
68 | "."; | 74 | "."; |
69 | 75 | ||
76 | AssertionArgument: | ||
77 | NodeAssertionArgument | ConstantAssertionArgument; | ||
78 | |||
79 | NodeAssertionArgument: | ||
80 | node=[Node|QualifiedName]; | ||
81 | |||
82 | ConstantAssertionArgument: | ||
83 | constant=Constant; | ||
84 | |||
70 | enum LogicValue: | 85 | enum LogicValue: |
71 | TRUE="true" | FALSE="false" | UNKNOWN="unknown"; | 86 | TRUE="true" | FALSE="false" | UNKNOWN="unknown"; |
72 | 87 | ||
73 | enum ShortLogicValue returns LogicValue: | 88 | enum ShortLogicValue returns LogicValue: |
74 | FALSE="!" | UNKNOWN="?"; | 89 | FALSE="!" | UNKNOWN="?"; |
75 | 90 | ||
91 | NodeValueAssertion: | ||
92 | node=[Node|QualifiedName] ":" value=Constant "."; | ||
93 | |||
94 | Constant: | ||
95 | IntConstant | RealConstant | StringConstant; | ||
96 | |||
97 | IntConstant: | ||
98 | intValue=Integer; | ||
99 | |||
100 | RealConstant: | ||
101 | realValue=Real; | ||
102 | |||
103 | StringConstant: | ||
104 | stringValue=STRING; | ||
105 | |||
76 | ScopeDeclaration: | 106 | ScopeDeclaration: |
77 | "scope" typeScopes+=TypeScope ("," typeScopes+=TypeScope)* "."; | 107 | "scope" typeScopes+=TypeScope ("," typeScopes+=TypeScope)* "."; |
78 | 108 | ||
@@ -102,11 +132,21 @@ UpperBound returns ecore::EInt: | |||
102 | QuotedOrUnquotedId: | 132 | QuotedOrUnquotedId: |
103 | QUOTED_ID | Identifier; | 133 | QUOTED_ID | Identifier; |
104 | 134 | ||
105 | QualifiedName: | 135 | QualifiedName hidden(): |
106 | QUOTED_ID | Identifier ("::" Identifier)* ("::" QUOTED_ID)?; | 136 | QUOTED_ID | Identifier ("::" Identifier)* ("::" QUOTED_ID)?; |
107 | 137 | ||
108 | Identifier: | 138 | Identifier: |
109 | ID | "true" | "false"; | 139 | ID | "true" | "false" | "e" | "E"; |
140 | |||
141 | Integer returns ecore::EInt hidden(): | ||
142 | "-"? INT; | ||
143 | |||
144 | Real returns ecore::EDouble hidden(): | ||
145 | "-"? INT ("." INT | ("." INT)? ("e" | "E") ("-" | "+")? INT); | ||
146 | |||
147 | @Override | ||
148 | terminal ID: | ||
149 | ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; | ||
110 | 150 | ||
111 | @Override | 151 | @Override |
112 | terminal STRING: | 152 | terminal STRING: |
@@ -117,4 +157,4 @@ terminal QUOTED_ID: | |||
117 | 157 | ||
118 | @Override | 158 | @Override |
119 | terminal SL_COMMENT: | 159 | terminal SL_COMMENT: |
120 | ('%' | '//') !('\n'|'\r')* ('\r'? '\n')?; | 160 | ('%' | '//') !('\n' | '\r')* ('\r'? '\n')?; |
diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/ProblemUtil.java b/language/src/main/java/org/eclipse/viatra/solver/language/ProblemUtil.java index 09f062f5..e0a72687 100644 --- a/language/src/main/java/org/eclipse/viatra/solver/language/ProblemUtil.java +++ b/language/src/main/java/org/eclipse/viatra/solver/language/ProblemUtil.java | |||
@@ -38,13 +38,13 @@ public final class ProblemUtil { | |||
38 | } | 38 | } |
39 | 39 | ||
40 | public static boolean isSingletonVariable(Variable variable) { | 40 | public static boolean isSingletonVariable(Variable variable) { |
41 | return variable.eContainingFeature() == ProblemPackage.Literals.ARGUMENT__SINGLETON_VARIABLE; | 41 | return variable.eContainingFeature() == ProblemPackage.Literals.VARIABLE_OR_NODE_ARGUMENT__SINGLETON_VARIABLE; |
42 | } | 42 | } |
43 | 43 | ||
44 | public static boolean isEnumLiteral(Node node) { | 44 | public static boolean isEnumLiteral(Node node) { |
45 | return node.eContainingFeature() == ProblemPackage.Literals.ENUM_DECLARATION__LITERALS; | 45 | return node.eContainingFeature() == ProblemPackage.Literals.ENUM_DECLARATION__LITERALS; |
46 | } | 46 | } |
47 | 47 | ||
48 | public static boolean isEnumNode(Node node) { | 48 | public static boolean isEnumNode(Node node) { |
49 | String name = node.getName(); | 49 | String name = node.getName(); |
50 | boolean isNameQuoted = name != null && name.startsWith(ENUM_NODE_NAME_QUOTE) | 50 | boolean isNameQuoted = name != null && name.startsWith(ENUM_NODE_NAME_QUOTE) |
diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemDerivedStateComputer.java b/language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemDerivedStateComputer.java index b885ce0e..fc03fa87 100644 --- a/language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemDerivedStateComputer.java +++ b/language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemDerivedStateComputer.java | |||
@@ -11,6 +11,7 @@ import org.eclipse.emf.ecore.EStructuralFeature; | |||
11 | import org.eclipse.viatra.solver.language.ProblemUtil; | 11 | import org.eclipse.viatra.solver.language.ProblemUtil; |
12 | import org.eclipse.viatra.solver.language.model.problem.Argument; | 12 | import org.eclipse.viatra.solver.language.model.problem.Argument; |
13 | import org.eclipse.viatra.solver.language.model.problem.Assertion; | 13 | import org.eclipse.viatra.solver.language.model.problem.Assertion; |
14 | import org.eclipse.viatra.solver.language.model.problem.AssertionArgument; | ||
14 | import org.eclipse.viatra.solver.language.model.problem.Atom; | 15 | import org.eclipse.viatra.solver.language.model.problem.Atom; |
15 | import org.eclipse.viatra.solver.language.model.problem.ClassDeclaration; | 16 | import org.eclipse.viatra.solver.language.model.problem.ClassDeclaration; |
16 | import org.eclipse.viatra.solver.language.model.problem.Conjunction; | 17 | import org.eclipse.viatra.solver.language.model.problem.Conjunction; |
@@ -19,12 +20,15 @@ import org.eclipse.viatra.solver.language.model.problem.ImplicitVariable; | |||
19 | import org.eclipse.viatra.solver.language.model.problem.Literal; | 20 | import org.eclipse.viatra.solver.language.model.problem.Literal; |
20 | import org.eclipse.viatra.solver.language.model.problem.NegativeLiteral; | 21 | import org.eclipse.viatra.solver.language.model.problem.NegativeLiteral; |
21 | import org.eclipse.viatra.solver.language.model.problem.Node; | 22 | import org.eclipse.viatra.solver.language.model.problem.Node; |
23 | import org.eclipse.viatra.solver.language.model.problem.NodeAssertionArgument; | ||
24 | import org.eclipse.viatra.solver.language.model.problem.NodeValueAssertion; | ||
22 | import org.eclipse.viatra.solver.language.model.problem.Parameter; | 25 | import org.eclipse.viatra.solver.language.model.problem.Parameter; |
23 | import org.eclipse.viatra.solver.language.model.problem.PredicateDefinition; | 26 | import org.eclipse.viatra.solver.language.model.problem.PredicateDefinition; |
24 | import org.eclipse.viatra.solver.language.model.problem.Problem; | 27 | import org.eclipse.viatra.solver.language.model.problem.Problem; |
25 | import org.eclipse.viatra.solver.language.model.problem.ProblemFactory; | 28 | import org.eclipse.viatra.solver.language.model.problem.ProblemFactory; |
26 | import org.eclipse.viatra.solver.language.model.problem.ProblemPackage; | 29 | import org.eclipse.viatra.solver.language.model.problem.ProblemPackage; |
27 | import org.eclipse.viatra.solver.language.model.problem.Statement; | 30 | import org.eclipse.viatra.solver.language.model.problem.Statement; |
31 | import org.eclipse.viatra.solver.language.model.problem.VariableOrNodeArgument; | ||
28 | import org.eclipse.xtext.linking.impl.LinkingHelper; | 32 | import org.eclipse.xtext.linking.impl.LinkingHelper; |
29 | import org.eclipse.xtext.naming.IQualifiedNameConverter; | 33 | import org.eclipse.xtext.naming.IQualifiedNameConverter; |
30 | import org.eclipse.xtext.naming.QualifiedName; | 34 | import org.eclipse.xtext.naming.QualifiedName; |
@@ -97,7 +101,16 @@ public class ProblemDerivedStateComputer implements IDerivedStateComputer { | |||
97 | Set<String> nodeNames = new HashSet<>(); | 101 | Set<String> nodeNames = new HashSet<>(); |
98 | for (Statement statement : problem.getStatements()) { | 102 | for (Statement statement : problem.getStatements()) { |
99 | if (statement instanceof Assertion) { | 103 | if (statement instanceof Assertion) { |
100 | addNodeNames(nodeNames, nodeScope, statement, ProblemPackage.Literals.ASSERTION__ARGUMENTS, | 104 | Assertion assertion = (Assertion) statement; |
105 | for (AssertionArgument argument : assertion.getArguments()) { | ||
106 | if (argument instanceof NodeAssertionArgument) { | ||
107 | addNodeNames(nodeNames, nodeScope, argument, | ||
108 | ProblemPackage.Literals.NODE_ASSERTION_ARGUMENT__NODE, | ||
109 | ProblemDerivedStateComputer::validNodeName); | ||
110 | } | ||
111 | } | ||
112 | } else if (statement instanceof NodeValueAssertion) { | ||
113 | addNodeNames(nodeNames, nodeScope, statement, ProblemPackage.Literals.NODE_VALUE_ASSERTION__NODE, | ||
101 | ProblemDerivedStateComputer::validNodeName); | 114 | ProblemDerivedStateComputer::validNodeName); |
102 | } else if (statement instanceof PredicateDefinition) { | 115 | } else if (statement instanceof PredicateDefinition) { |
103 | PredicateDefinition predicateDefinition = (PredicateDefinition) statement; | 116 | PredicateDefinition predicateDefinition = (PredicateDefinition) statement; |
@@ -114,9 +127,11 @@ public class ProblemDerivedStateComputer implements IDerivedStateComputer { | |||
114 | continue; | 127 | continue; |
115 | } | 128 | } |
116 | for (Argument argument : atom.getArguments()) { | 129 | for (Argument argument : atom.getArguments()) { |
117 | addNodeNames(nodeNames, nodeScope, argument, | 130 | if (argument instanceof VariableOrNodeArgument) { |
118 | ProblemPackage.Literals.ARGUMENT__VARIABLE_OR_NODE, | 131 | addNodeNames(nodeNames, nodeScope, argument, |
119 | ProblemDerivedStateComputer::validQuotedId); | 132 | ProblemPackage.Literals.VARIABLE_OR_NODE_ARGUMENT__VARIABLE_OR_NODE, |
133 | ProblemDerivedStateComputer::validQuotedId); | ||
134 | } | ||
120 | } | 135 | } |
121 | } | 136 | } |
122 | } | 137 | } |
@@ -189,29 +204,31 @@ public class ProblemDerivedStateComputer implements IDerivedStateComputer { | |||
189 | 204 | ||
190 | protected void createSigletonVariablesAndCollectVariables(Atom atom, Set<String> knownVariables, | 205 | protected void createSigletonVariablesAndCollectVariables(Atom atom, Set<String> knownVariables, |
191 | Set<String> newVariables) { | 206 | Set<String> newVariables) { |
192 | IScope scope = scopeProvider.getScope(atom, ProblemPackage.Literals.ARGUMENT__VARIABLE_OR_NODE); | 207 | for (Argument argument : atom.getArguments()) { |
193 | List<INode> nodes = NodeModelUtils.findNodesForFeature(atom, ProblemPackage.Literals.ATOM__ARGUMENTS); | 208 | if (argument instanceof VariableOrNodeArgument) { |
194 | int nodesSize = nodes.size(); | 209 | VariableOrNodeArgument variableOrNodeArgument = (VariableOrNodeArgument) argument; |
195 | List<Argument> arguments = atom.getArguments(); | 210 | IScope scope = scopeProvider.getScope(variableOrNodeArgument, |
196 | int argumentsSize = arguments.size(); | 211 | ProblemPackage.Literals.VARIABLE_OR_NODE_ARGUMENT__VARIABLE_OR_NODE); |
197 | for (int i = 0; i < nodesSize; i++) { | 212 | List<INode> nodes = NodeModelUtils.findNodesForFeature(variableOrNodeArgument, |
198 | INode node = nodes.get(i); | 213 | ProblemPackage.Literals.VARIABLE_OR_NODE_ARGUMENT__VARIABLE_OR_NODE); |
199 | String variableName = linkingHelper.getCrossRefNodeAsString(node, true); | 214 | for (INode node : nodes) { |
200 | if (!validId(variableName)) { | 215 | String variableName = linkingHelper.getCrossRefNodeAsString(node, true); |
201 | continue; | 216 | if (!validId(variableName)) { |
202 | } | 217 | continue; |
203 | QualifiedName qualifiedName = qualifiedNameConverter.toQualifiedName(variableName); | 218 | } |
204 | if (scope.getSingleElement(qualifiedName) != null) { | 219 | QualifiedName qualifiedName = qualifiedNameConverter.toQualifiedName(variableName); |
205 | continue; | 220 | if (scope.getSingleElement(qualifiedName) != null) { |
206 | } | 221 | continue; |
207 | if (ProblemUtil.isSingletonVariableName(variableName)) { | 222 | } |
208 | if (i < argumentsSize) { | 223 | if (ProblemUtil.isSingletonVariableName(variableName)) { |
209 | createSingletonVariable(arguments.get(i), variableName); | 224 | createSingletonVariable(variableOrNodeArgument, variableName); |
225 | break; | ||
226 | } | ||
227 | if (!knownVariables.contains(variableName)) { | ||
228 | newVariables.add(variableName); | ||
229 | break; | ||
230 | } | ||
210 | } | 231 | } |
211 | continue; | ||
212 | } | ||
213 | if (!knownVariables.contains(variableName)) { | ||
214 | newVariables.add(variableName); | ||
215 | } | 232 | } |
216 | } | 233 | } |
217 | } | 234 | } |
@@ -229,7 +246,7 @@ public class ProblemDerivedStateComputer implements IDerivedStateComputer { | |||
229 | } | 246 | } |
230 | } | 247 | } |
231 | 248 | ||
232 | protected void createSingletonVariable(Argument argument, String variableName) { | 249 | protected void createSingletonVariable(VariableOrNodeArgument argument, String variableName) { |
233 | if (validId(variableName)) { | 250 | if (validId(variableName)) { |
234 | ImplicitVariable variable = createNamedVariable(variableName); | 251 | ImplicitVariable variable = createNamedVariable(variableName); |
235 | argument.setSingletonVariable(variable); | 252 | argument.setSingletonVariable(variable); |
@@ -281,7 +298,10 @@ public class ProblemDerivedStateComputer implements IDerivedStateComputer { | |||
281 | return; | 298 | return; |
282 | } | 299 | } |
283 | for (Argument argument : atom.getArguments()) { | 300 | for (Argument argument : atom.getArguments()) { |
284 | argument.setSingletonVariable(null); | 301 | if (argument instanceof VariableOrNodeArgument) { |
302 | VariableOrNodeArgument variableOrNodeArgument = (VariableOrNodeArgument) argument; | ||
303 | variableOrNodeArgument.setSingletonVariable(null); | ||
304 | } | ||
285 | } | 305 | } |
286 | } | 306 | } |
287 | 307 | ||
diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/scoping/ProblemScopeProvider.java b/language/src/main/java/org/eclipse/viatra/solver/language/scoping/ProblemScopeProvider.java index fc4034ae..3748e81d 100644 --- a/language/src/main/java/org/eclipse/viatra/solver/language/scoping/ProblemScopeProvider.java +++ b/language/src/main/java/org/eclipse/viatra/solver/language/scoping/ProblemScopeProvider.java | |||
@@ -10,7 +10,6 @@ import java.util.List; | |||
10 | import org.eclipse.emf.ecore.EObject; | 10 | import org.eclipse.emf.ecore.EObject; |
11 | import org.eclipse.emf.ecore.EReference; | 11 | import org.eclipse.emf.ecore.EReference; |
12 | import org.eclipse.viatra.solver.language.ProblemUtil; | 12 | import org.eclipse.viatra.solver.language.ProblemUtil; |
13 | import org.eclipse.viatra.solver.language.model.problem.Argument; | ||
14 | import org.eclipse.viatra.solver.language.model.problem.ClassDeclaration; | 13 | import org.eclipse.viatra.solver.language.model.problem.ClassDeclaration; |
15 | import org.eclipse.viatra.solver.language.model.problem.ExistentialQuantifier; | 14 | import org.eclipse.viatra.solver.language.model.problem.ExistentialQuantifier; |
16 | import org.eclipse.viatra.solver.language.model.problem.PredicateDefinition; | 15 | import org.eclipse.viatra.solver.language.model.problem.PredicateDefinition; |
@@ -18,6 +17,7 @@ import org.eclipse.viatra.solver.language.model.problem.ProblemPackage; | |||
18 | import org.eclipse.viatra.solver.language.model.problem.ReferenceDeclaration; | 17 | import org.eclipse.viatra.solver.language.model.problem.ReferenceDeclaration; |
19 | import org.eclipse.viatra.solver.language.model.problem.Relation; | 18 | import org.eclipse.viatra.solver.language.model.problem.Relation; |
20 | import org.eclipse.viatra.solver.language.model.problem.Variable; | 19 | import org.eclipse.viatra.solver.language.model.problem.Variable; |
20 | import org.eclipse.viatra.solver.language.model.problem.VariableOrNodeArgument; | ||
21 | import org.eclipse.xtext.EcoreUtil2; | 21 | import org.eclipse.xtext.EcoreUtil2; |
22 | import org.eclipse.xtext.scoping.IScope; | 22 | import org.eclipse.xtext.scoping.IScope; |
23 | import org.eclipse.xtext.scoping.Scopes; | 23 | import org.eclipse.xtext.scoping.Scopes; |
@@ -34,7 +34,7 @@ public class ProblemScopeProvider extends AbstractProblemScopeProvider { | |||
34 | @Override | 34 | @Override |
35 | public IScope getScope(EObject context, EReference reference) { | 35 | public IScope getScope(EObject context, EReference reference) { |
36 | IScope scope = super.getScope(context, reference); | 36 | IScope scope = super.getScope(context, reference); |
37 | if (reference == ProblemPackage.Literals.ARGUMENT__VARIABLE_OR_NODE) { | 37 | if (reference == ProblemPackage.Literals.VARIABLE_OR_NODE_ARGUMENT__VARIABLE_OR_NODE) { |
38 | return getVariableScope(context, scope); | 38 | return getVariableScope(context, scope); |
39 | } else if (reference == ProblemPackage.Literals.REFERENCE_DECLARATION__OPPOSITE) { | 39 | } else if (reference == ProblemPackage.Literals.REFERENCE_DECLARATION__OPPOSITE) { |
40 | return getOppositeScope(context, scope); | 40 | return getOppositeScope(context, scope); |
@@ -45,8 +45,8 @@ public class ProblemScopeProvider extends AbstractProblemScopeProvider { | |||
45 | protected IScope getVariableScope(EObject context, IScope delegateScope) { | 45 | protected IScope getVariableScope(EObject context, IScope delegateScope) { |
46 | List<Variable> variables = new ArrayList<>(); | 46 | List<Variable> variables = new ArrayList<>(); |
47 | EObject currentContext = context; | 47 | EObject currentContext = context; |
48 | if (context instanceof Argument) { | 48 | if (context instanceof VariableOrNodeArgument) { |
49 | Argument argument = (Argument) context; | 49 | VariableOrNodeArgument argument = (VariableOrNodeArgument) context; |
50 | Variable singletonVariable = argument.getSingletonVariable(); | 50 | Variable singletonVariable = argument.getSingletonVariable(); |
51 | if (singletonVariable != null) { | 51 | if (singletonVariable != null) { |
52 | variables.add(singletonVariable); | 52 | variables.add(singletonVariable); |
diff --git a/language/src/main/resources/org/eclipse/viatra/solver/language/builtin.problem b/language/src/main/resources/org/eclipse/viatra/solver/language/builtin.problem index 13398ce8..7ece2db0 100644 --- a/language/src/main/resources/org/eclipse/viatra/solver/language/builtin.problem +++ b/language/src/main/resources/org/eclipse/viatra/solver/language/builtin.problem | |||
@@ -6,12 +6,16 @@ abstract class node { | |||
6 | 6 | ||
7 | pred exists(node node). | 7 | pred exists(node node). |
8 | 8 | ||
9 | abstract class domain extends node. | ||
10 | |||
11 | abstract class data extends node. | ||
12 | |||
9 | enum bool { | 13 | enum bool { |
10 | true, false | 14 | true, false |
11 | } | 15 | } |
12 | 16 | ||
13 | class double. | 17 | class real extends data. |
14 | 18 | ||
15 | class int extends double. | 19 | class int extends real. |
16 | 20 | ||
17 | class string. | 21 | class string extends data. |
diff --git a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/Problem.xtextbin b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/Problem.xtextbin index dc21001d..a5b00fe3 100644 --- a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/Problem.xtextbin +++ b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/Problem.xtextbin | |||
Binary files differ | |||
diff --git a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblem.g b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblem.g index 3a368756..4ef02d71 100644 --- a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblem.g +++ b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblem.g | |||
@@ -181,11 +181,20 @@ ruleStatement returns [EObject current=null] | |||
181 | } | 181 | } |
182 | | | 182 | | |
183 | { | 183 | { |
184 | newCompositeNode(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_4()); | 184 | newCompositeNode(grammarAccess.getStatementAccess().getNodeValueAssertionParserRuleCall_4()); |
185 | } | 185 | } |
186 | this_ScopeDeclaration_4=ruleScopeDeclaration | 186 | this_NodeValueAssertion_4=ruleNodeValueAssertion |
187 | { | 187 | { |
188 | $current = $this_ScopeDeclaration_4.current; | 188 | $current = $this_NodeValueAssertion_4.current; |
189 | afterParserOrEnumRuleCall(); | ||
190 | } | ||
191 | | | ||
192 | { | ||
193 | newCompositeNode(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_5()); | ||
194 | } | ||
195 | this_ScopeDeclaration_5=ruleScopeDeclaration | ||
196 | { | ||
197 | $current = $this_ScopeDeclaration_5.current; | ||
189 | afterParserOrEnumRuleCall(); | 198 | afterParserOrEnumRuleCall(); |
190 | } | 199 | } |
191 | ) | 200 | ) |
@@ -1102,14 +1111,50 @@ ruleArgument returns [EObject current=null] | |||
1102 | leaveRule(); | 1111 | leaveRule(); |
1103 | }: | 1112 | }: |
1104 | ( | 1113 | ( |
1114 | { | ||
1115 | newCompositeNode(grammarAccess.getArgumentAccess().getVariableOrNodeArgumentParserRuleCall_0()); | ||
1116 | } | ||
1117 | this_VariableOrNodeArgument_0=ruleVariableOrNodeArgument | ||
1118 | { | ||
1119 | $current = $this_VariableOrNodeArgument_0.current; | ||
1120 | afterParserOrEnumRuleCall(); | ||
1121 | } | ||
1122 | | | ||
1123 | { | ||
1124 | newCompositeNode(grammarAccess.getArgumentAccess().getConstantArgumentParserRuleCall_1()); | ||
1125 | } | ||
1126 | this_ConstantArgument_1=ruleConstantArgument | ||
1127 | { | ||
1128 | $current = $this_ConstantArgument_1.current; | ||
1129 | afterParserOrEnumRuleCall(); | ||
1130 | } | ||
1131 | ) | ||
1132 | ; | ||
1133 | |||
1134 | // Entry rule entryRuleVariableOrNodeArgument | ||
1135 | entryRuleVariableOrNodeArgument returns [EObject current=null]: | ||
1136 | { newCompositeNode(grammarAccess.getVariableOrNodeArgumentRule()); } | ||
1137 | iv_ruleVariableOrNodeArgument=ruleVariableOrNodeArgument | ||
1138 | { $current=$iv_ruleVariableOrNodeArgument.current; } | ||
1139 | EOF; | ||
1140 | |||
1141 | // Rule VariableOrNodeArgument | ||
1142 | ruleVariableOrNodeArgument returns [EObject current=null] | ||
1143 | @init { | ||
1144 | enterRule(); | ||
1145 | } | ||
1146 | @after { | ||
1147 | leaveRule(); | ||
1148 | }: | ||
1149 | ( | ||
1105 | ( | 1150 | ( |
1106 | { | 1151 | { |
1107 | if ($current==null) { | 1152 | if ($current==null) { |
1108 | $current = createModelElement(grammarAccess.getArgumentRule()); | 1153 | $current = createModelElement(grammarAccess.getVariableOrNodeArgumentRule()); |
1109 | } | 1154 | } |
1110 | } | 1155 | } |
1111 | { | 1156 | { |
1112 | newCompositeNode(grammarAccess.getArgumentAccess().getVariableOrNodeVariableOrNodeCrossReference_0()); | 1157 | newCompositeNode(grammarAccess.getVariableOrNodeArgumentAccess().getVariableOrNodeVariableOrNodeCrossReference_0()); |
1113 | } | 1158 | } |
1114 | ruleQualifiedName | 1159 | ruleQualifiedName |
1115 | { | 1160 | { |
@@ -1119,6 +1164,42 @@ ruleArgument returns [EObject current=null] | |||
1119 | ) | 1164 | ) |
1120 | ; | 1165 | ; |
1121 | 1166 | ||
1167 | // Entry rule entryRuleConstantArgument | ||
1168 | entryRuleConstantArgument returns [EObject current=null]: | ||
1169 | { newCompositeNode(grammarAccess.getConstantArgumentRule()); } | ||
1170 | iv_ruleConstantArgument=ruleConstantArgument | ||
1171 | { $current=$iv_ruleConstantArgument.current; } | ||
1172 | EOF; | ||
1173 | |||
1174 | // Rule ConstantArgument | ||
1175 | ruleConstantArgument returns [EObject current=null] | ||
1176 | @init { | ||
1177 | enterRule(); | ||
1178 | } | ||
1179 | @after { | ||
1180 | leaveRule(); | ||
1181 | }: | ||
1182 | ( | ||
1183 | ( | ||
1184 | { | ||
1185 | newCompositeNode(grammarAccess.getConstantArgumentAccess().getConstantConstantParserRuleCall_0()); | ||
1186 | } | ||
1187 | lv_constant_0_0=ruleConstant | ||
1188 | { | ||
1189 | if ($current==null) { | ||
1190 | $current = createModelElementForParent(grammarAccess.getConstantArgumentRule()); | ||
1191 | } | ||
1192 | set( | ||
1193 | $current, | ||
1194 | "constant", | ||
1195 | lv_constant_0_0, | ||
1196 | "org.eclipse.viatra.solver.language.Problem.Constant"); | ||
1197 | afterParserOrEnumRuleCall(); | ||
1198 | } | ||
1199 | ) | ||
1200 | ) | ||
1201 | ; | ||
1202 | |||
1122 | // Entry rule entryRuleAssertion | 1203 | // Entry rule entryRuleAssertion |
1123 | entryRuleAssertion returns [EObject current=null]: | 1204 | entryRuleAssertion returns [EObject current=null]: |
1124 | { newCompositeNode(grammarAccess.getAssertionRule()); } | 1205 | { newCompositeNode(grammarAccess.getAssertionRule()); } |
@@ -1161,15 +1242,18 @@ ruleAssertion returns [EObject current=null] | |||
1161 | ( | 1242 | ( |
1162 | ( | 1243 | ( |
1163 | { | 1244 | { |
1164 | if ($current==null) { | 1245 | newCompositeNode(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_0_2_0_0()); |
1165 | $current = createModelElement(grammarAccess.getAssertionRule()); | ||
1166 | } | ||
1167 | } | ||
1168 | { | ||
1169 | newCompositeNode(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_0_2_0_0()); | ||
1170 | } | 1246 | } |
1171 | ruleQualifiedName | 1247 | lv_arguments_2_0=ruleAssertionArgument |
1172 | { | 1248 | { |
1249 | if ($current==null) { | ||
1250 | $current = createModelElementForParent(grammarAccess.getAssertionRule()); | ||
1251 | } | ||
1252 | add( | ||
1253 | $current, | ||
1254 | "arguments", | ||
1255 | lv_arguments_2_0, | ||
1256 | "org.eclipse.viatra.solver.language.Problem.AssertionArgument"); | ||
1173 | afterParserOrEnumRuleCall(); | 1257 | afterParserOrEnumRuleCall(); |
1174 | } | 1258 | } |
1175 | ) | 1259 | ) |
@@ -1182,15 +1266,18 @@ ruleAssertion returns [EObject current=null] | |||
1182 | ( | 1266 | ( |
1183 | ( | 1267 | ( |
1184 | { | 1268 | { |
1185 | if ($current==null) { | 1269 | newCompositeNode(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_0_2_1_1_0()); |
1186 | $current = createModelElement(grammarAccess.getAssertionRule()); | ||
1187 | } | ||
1188 | } | 1270 | } |
1271 | lv_arguments_4_0=ruleAssertionArgument | ||
1189 | { | 1272 | { |
1190 | newCompositeNode(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_0_2_1_1_0()); | 1273 | if ($current==null) { |
1191 | } | 1274 | $current = createModelElementForParent(grammarAccess.getAssertionRule()); |
1192 | ruleQualifiedName | 1275 | } |
1193 | { | 1276 | add( |
1277 | $current, | ||
1278 | "arguments", | ||
1279 | lv_arguments_4_0, | ||
1280 | "org.eclipse.viatra.solver.language.Problem.AssertionArgument"); | ||
1194 | afterParserOrEnumRuleCall(); | 1281 | afterParserOrEnumRuleCall(); |
1195 | } | 1282 | } |
1196 | ) | 1283 | ) |
@@ -1270,15 +1357,18 @@ ruleAssertion returns [EObject current=null] | |||
1270 | ( | 1357 | ( |
1271 | ( | 1358 | ( |
1272 | { | 1359 | { |
1273 | if ($current==null) { | 1360 | newCompositeNode(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_1_3_0_0()); |
1274 | $current = createModelElement(grammarAccess.getAssertionRule()); | ||
1275 | } | ||
1276 | } | ||
1277 | { | ||
1278 | newCompositeNode(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_1_3_0_0()); | ||
1279 | } | 1361 | } |
1280 | ruleQualifiedName | 1362 | lv_arguments_11_0=ruleAssertionArgument |
1281 | { | 1363 | { |
1364 | if ($current==null) { | ||
1365 | $current = createModelElementForParent(grammarAccess.getAssertionRule()); | ||
1366 | } | ||
1367 | add( | ||
1368 | $current, | ||
1369 | "arguments", | ||
1370 | lv_arguments_11_0, | ||
1371 | "org.eclipse.viatra.solver.language.Problem.AssertionArgument"); | ||
1282 | afterParserOrEnumRuleCall(); | 1372 | afterParserOrEnumRuleCall(); |
1283 | } | 1373 | } |
1284 | ) | 1374 | ) |
@@ -1291,15 +1381,18 @@ ruleAssertion returns [EObject current=null] | |||
1291 | ( | 1381 | ( |
1292 | ( | 1382 | ( |
1293 | { | 1383 | { |
1294 | if ($current==null) { | 1384 | newCompositeNode(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_1_3_1_1_0()); |
1295 | $current = createModelElement(grammarAccess.getAssertionRule()); | ||
1296 | } | ||
1297 | } | ||
1298 | { | ||
1299 | newCompositeNode(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_1_3_1_1_0()); | ||
1300 | } | 1385 | } |
1301 | ruleQualifiedName | 1386 | lv_arguments_13_0=ruleAssertionArgument |
1302 | { | 1387 | { |
1388 | if ($current==null) { | ||
1389 | $current = createModelElementForParent(grammarAccess.getAssertionRule()); | ||
1390 | } | ||
1391 | add( | ||
1392 | $current, | ||
1393 | "arguments", | ||
1394 | lv_arguments_13_0, | ||
1395 | "org.eclipse.viatra.solver.language.Problem.AssertionArgument"); | ||
1303 | afterParserOrEnumRuleCall(); | 1396 | afterParserOrEnumRuleCall(); |
1304 | } | 1397 | } |
1305 | ) | 1398 | ) |
@@ -1319,6 +1412,325 @@ ruleAssertion returns [EObject current=null] | |||
1319 | ) | 1412 | ) |
1320 | ; | 1413 | ; |
1321 | 1414 | ||
1415 | // Entry rule entryRuleAssertionArgument | ||
1416 | entryRuleAssertionArgument returns [EObject current=null]: | ||
1417 | { newCompositeNode(grammarAccess.getAssertionArgumentRule()); } | ||
1418 | iv_ruleAssertionArgument=ruleAssertionArgument | ||
1419 | { $current=$iv_ruleAssertionArgument.current; } | ||
1420 | EOF; | ||
1421 | |||
1422 | // Rule AssertionArgument | ||
1423 | ruleAssertionArgument returns [EObject current=null] | ||
1424 | @init { | ||
1425 | enterRule(); | ||
1426 | } | ||
1427 | @after { | ||
1428 | leaveRule(); | ||
1429 | }: | ||
1430 | ( | ||
1431 | { | ||
1432 | newCompositeNode(grammarAccess.getAssertionArgumentAccess().getNodeAssertionArgumentParserRuleCall_0()); | ||
1433 | } | ||
1434 | this_NodeAssertionArgument_0=ruleNodeAssertionArgument | ||
1435 | { | ||
1436 | $current = $this_NodeAssertionArgument_0.current; | ||
1437 | afterParserOrEnumRuleCall(); | ||
1438 | } | ||
1439 | | | ||
1440 | { | ||
1441 | newCompositeNode(grammarAccess.getAssertionArgumentAccess().getConstantAssertionArgumentParserRuleCall_1()); | ||
1442 | } | ||
1443 | this_ConstantAssertionArgument_1=ruleConstantAssertionArgument | ||
1444 | { | ||
1445 | $current = $this_ConstantAssertionArgument_1.current; | ||
1446 | afterParserOrEnumRuleCall(); | ||
1447 | } | ||
1448 | ) | ||
1449 | ; | ||
1450 | |||
1451 | // Entry rule entryRuleNodeAssertionArgument | ||
1452 | entryRuleNodeAssertionArgument returns [EObject current=null]: | ||
1453 | { newCompositeNode(grammarAccess.getNodeAssertionArgumentRule()); } | ||
1454 | iv_ruleNodeAssertionArgument=ruleNodeAssertionArgument | ||
1455 | { $current=$iv_ruleNodeAssertionArgument.current; } | ||
1456 | EOF; | ||
1457 | |||
1458 | // Rule NodeAssertionArgument | ||
1459 | ruleNodeAssertionArgument returns [EObject current=null] | ||
1460 | @init { | ||
1461 | enterRule(); | ||
1462 | } | ||
1463 | @after { | ||
1464 | leaveRule(); | ||
1465 | }: | ||
1466 | ( | ||
1467 | ( | ||
1468 | { | ||
1469 | if ($current==null) { | ||
1470 | $current = createModelElement(grammarAccess.getNodeAssertionArgumentRule()); | ||
1471 | } | ||
1472 | } | ||
1473 | { | ||
1474 | newCompositeNode(grammarAccess.getNodeAssertionArgumentAccess().getNodeNodeCrossReference_0()); | ||
1475 | } | ||
1476 | ruleQualifiedName | ||
1477 | { | ||
1478 | afterParserOrEnumRuleCall(); | ||
1479 | } | ||
1480 | ) | ||
1481 | ) | ||
1482 | ; | ||
1483 | |||
1484 | // Entry rule entryRuleConstantAssertionArgument | ||
1485 | entryRuleConstantAssertionArgument returns [EObject current=null]: | ||
1486 | { newCompositeNode(grammarAccess.getConstantAssertionArgumentRule()); } | ||
1487 | iv_ruleConstantAssertionArgument=ruleConstantAssertionArgument | ||
1488 | { $current=$iv_ruleConstantAssertionArgument.current; } | ||
1489 | EOF; | ||
1490 | |||
1491 | // Rule ConstantAssertionArgument | ||
1492 | ruleConstantAssertionArgument returns [EObject current=null] | ||
1493 | @init { | ||
1494 | enterRule(); | ||
1495 | } | ||
1496 | @after { | ||
1497 | leaveRule(); | ||
1498 | }: | ||
1499 | ( | ||
1500 | ( | ||
1501 | { | ||
1502 | newCompositeNode(grammarAccess.getConstantAssertionArgumentAccess().getConstantConstantParserRuleCall_0()); | ||
1503 | } | ||
1504 | lv_constant_0_0=ruleConstant | ||
1505 | { | ||
1506 | if ($current==null) { | ||
1507 | $current = createModelElementForParent(grammarAccess.getConstantAssertionArgumentRule()); | ||
1508 | } | ||
1509 | set( | ||
1510 | $current, | ||
1511 | "constant", | ||
1512 | lv_constant_0_0, | ||
1513 | "org.eclipse.viatra.solver.language.Problem.Constant"); | ||
1514 | afterParserOrEnumRuleCall(); | ||
1515 | } | ||
1516 | ) | ||
1517 | ) | ||
1518 | ; | ||
1519 | |||
1520 | // Entry rule entryRuleNodeValueAssertion | ||
1521 | entryRuleNodeValueAssertion returns [EObject current=null]: | ||
1522 | { newCompositeNode(grammarAccess.getNodeValueAssertionRule()); } | ||
1523 | iv_ruleNodeValueAssertion=ruleNodeValueAssertion | ||
1524 | { $current=$iv_ruleNodeValueAssertion.current; } | ||
1525 | EOF; | ||
1526 | |||
1527 | // Rule NodeValueAssertion | ||
1528 | ruleNodeValueAssertion returns [EObject current=null] | ||
1529 | @init { | ||
1530 | enterRule(); | ||
1531 | } | ||
1532 | @after { | ||
1533 | leaveRule(); | ||
1534 | }: | ||
1535 | ( | ||
1536 | ( | ||
1537 | ( | ||
1538 | { | ||
1539 | if ($current==null) { | ||
1540 | $current = createModelElement(grammarAccess.getNodeValueAssertionRule()); | ||
1541 | } | ||
1542 | } | ||
1543 | { | ||
1544 | newCompositeNode(grammarAccess.getNodeValueAssertionAccess().getNodeNodeCrossReference_0_0()); | ||
1545 | } | ||
1546 | ruleQualifiedName | ||
1547 | { | ||
1548 | afterParserOrEnumRuleCall(); | ||
1549 | } | ||
1550 | ) | ||
1551 | ) | ||
1552 | otherlv_1=':' | ||
1553 | { | ||
1554 | newLeafNode(otherlv_1, grammarAccess.getNodeValueAssertionAccess().getColonKeyword_1()); | ||
1555 | } | ||
1556 | ( | ||
1557 | ( | ||
1558 | { | ||
1559 | newCompositeNode(grammarAccess.getNodeValueAssertionAccess().getValueConstantParserRuleCall_2_0()); | ||
1560 | } | ||
1561 | lv_value_2_0=ruleConstant | ||
1562 | { | ||
1563 | if ($current==null) { | ||
1564 | $current = createModelElementForParent(grammarAccess.getNodeValueAssertionRule()); | ||
1565 | } | ||
1566 | set( | ||
1567 | $current, | ||
1568 | "value", | ||
1569 | lv_value_2_0, | ||
1570 | "org.eclipse.viatra.solver.language.Problem.Constant"); | ||
1571 | afterParserOrEnumRuleCall(); | ||
1572 | } | ||
1573 | ) | ||
1574 | ) | ||
1575 | otherlv_3='.' | ||
1576 | { | ||
1577 | newLeafNode(otherlv_3, grammarAccess.getNodeValueAssertionAccess().getFullStopKeyword_3()); | ||
1578 | } | ||
1579 | ) | ||
1580 | ; | ||
1581 | |||
1582 | // Entry rule entryRuleConstant | ||
1583 | entryRuleConstant returns [EObject current=null]: | ||
1584 | { newCompositeNode(grammarAccess.getConstantRule()); } | ||
1585 | iv_ruleConstant=ruleConstant | ||
1586 | { $current=$iv_ruleConstant.current; } | ||
1587 | EOF; | ||
1588 | |||
1589 | // Rule Constant | ||
1590 | ruleConstant returns [EObject current=null] | ||
1591 | @init { | ||
1592 | enterRule(); | ||
1593 | } | ||
1594 | @after { | ||
1595 | leaveRule(); | ||
1596 | }: | ||
1597 | ( | ||
1598 | { | ||
1599 | newCompositeNode(grammarAccess.getConstantAccess().getIntConstantParserRuleCall_0()); | ||
1600 | } | ||
1601 | this_IntConstant_0=ruleIntConstant | ||
1602 | { | ||
1603 | $current = $this_IntConstant_0.current; | ||
1604 | afterParserOrEnumRuleCall(); | ||
1605 | } | ||
1606 | | | ||
1607 | { | ||
1608 | newCompositeNode(grammarAccess.getConstantAccess().getRealConstantParserRuleCall_1()); | ||
1609 | } | ||
1610 | this_RealConstant_1=ruleRealConstant | ||
1611 | { | ||
1612 | $current = $this_RealConstant_1.current; | ||
1613 | afterParserOrEnumRuleCall(); | ||
1614 | } | ||
1615 | | | ||
1616 | { | ||
1617 | newCompositeNode(grammarAccess.getConstantAccess().getStringConstantParserRuleCall_2()); | ||
1618 | } | ||
1619 | this_StringConstant_2=ruleStringConstant | ||
1620 | { | ||
1621 | $current = $this_StringConstant_2.current; | ||
1622 | afterParserOrEnumRuleCall(); | ||
1623 | } | ||
1624 | ) | ||
1625 | ; | ||
1626 | |||
1627 | // Entry rule entryRuleIntConstant | ||
1628 | entryRuleIntConstant returns [EObject current=null]: | ||
1629 | { newCompositeNode(grammarAccess.getIntConstantRule()); } | ||
1630 | iv_ruleIntConstant=ruleIntConstant | ||
1631 | { $current=$iv_ruleIntConstant.current; } | ||
1632 | EOF; | ||
1633 | |||
1634 | // Rule IntConstant | ||
1635 | ruleIntConstant returns [EObject current=null] | ||
1636 | @init { | ||
1637 | enterRule(); | ||
1638 | } | ||
1639 | @after { | ||
1640 | leaveRule(); | ||
1641 | }: | ||
1642 | ( | ||
1643 | ( | ||
1644 | { | ||
1645 | newCompositeNode(grammarAccess.getIntConstantAccess().getIntValueIntegerParserRuleCall_0()); | ||
1646 | } | ||
1647 | lv_intValue_0_0=ruleInteger | ||
1648 | { | ||
1649 | if ($current==null) { | ||
1650 | $current = createModelElementForParent(grammarAccess.getIntConstantRule()); | ||
1651 | } | ||
1652 | set( | ||
1653 | $current, | ||
1654 | "intValue", | ||
1655 | lv_intValue_0_0, | ||
1656 | "org.eclipse.viatra.solver.language.Problem.Integer"); | ||
1657 | afterParserOrEnumRuleCall(); | ||
1658 | } | ||
1659 | ) | ||
1660 | ) | ||
1661 | ; | ||
1662 | |||
1663 | // Entry rule entryRuleRealConstant | ||
1664 | entryRuleRealConstant returns [EObject current=null]: | ||
1665 | { newCompositeNode(grammarAccess.getRealConstantRule()); } | ||
1666 | iv_ruleRealConstant=ruleRealConstant | ||
1667 | { $current=$iv_ruleRealConstant.current; } | ||
1668 | EOF; | ||
1669 | |||
1670 | // Rule RealConstant | ||
1671 | ruleRealConstant returns [EObject current=null] | ||
1672 | @init { | ||
1673 | enterRule(); | ||
1674 | } | ||
1675 | @after { | ||
1676 | leaveRule(); | ||
1677 | }: | ||
1678 | ( | ||
1679 | ( | ||
1680 | { | ||
1681 | newCompositeNode(grammarAccess.getRealConstantAccess().getRealValueRealParserRuleCall_0()); | ||
1682 | } | ||
1683 | lv_realValue_0_0=ruleReal | ||
1684 | { | ||
1685 | if ($current==null) { | ||
1686 | $current = createModelElementForParent(grammarAccess.getRealConstantRule()); | ||
1687 | } | ||
1688 | set( | ||
1689 | $current, | ||
1690 | "realValue", | ||
1691 | lv_realValue_0_0, | ||
1692 | "org.eclipse.viatra.solver.language.Problem.Real"); | ||
1693 | afterParserOrEnumRuleCall(); | ||
1694 | } | ||
1695 | ) | ||
1696 | ) | ||
1697 | ; | ||
1698 | |||
1699 | // Entry rule entryRuleStringConstant | ||
1700 | entryRuleStringConstant returns [EObject current=null]: | ||
1701 | { newCompositeNode(grammarAccess.getStringConstantRule()); } | ||
1702 | iv_ruleStringConstant=ruleStringConstant | ||
1703 | { $current=$iv_ruleStringConstant.current; } | ||
1704 | EOF; | ||
1705 | |||
1706 | // Rule StringConstant | ||
1707 | ruleStringConstant returns [EObject current=null] | ||
1708 | @init { | ||
1709 | enterRule(); | ||
1710 | } | ||
1711 | @after { | ||
1712 | leaveRule(); | ||
1713 | }: | ||
1714 | ( | ||
1715 | ( | ||
1716 | lv_stringValue_0_0=RULE_STRING | ||
1717 | { | ||
1718 | newLeafNode(lv_stringValue_0_0, grammarAccess.getStringConstantAccess().getStringValueSTRINGTerminalRuleCall_0()); | ||
1719 | } | ||
1720 | { | ||
1721 | if ($current==null) { | ||
1722 | $current = createModelElement(grammarAccess.getStringConstantRule()); | ||
1723 | } | ||
1724 | setWithLastConsumed( | ||
1725 | $current, | ||
1726 | "stringValue", | ||
1727 | lv_stringValue_0_0, | ||
1728 | "org.eclipse.viatra.solver.language.Problem.STRING"); | ||
1729 | } | ||
1730 | ) | ||
1731 | ) | ||
1732 | ; | ||
1733 | |||
1322 | // Entry rule entryRuleScopeDeclaration | 1734 | // Entry rule entryRuleScopeDeclaration |
1323 | entryRuleScopeDeclaration returns [EObject current=null]: | 1735 | entryRuleScopeDeclaration returns [EObject current=null]: |
1324 | { newCompositeNode(grammarAccess.getScopeDeclarationRule()); } | 1736 | { newCompositeNode(grammarAccess.getScopeDeclarationRule()); } |
@@ -1723,16 +2135,22 @@ ruleQuotedOrUnquotedId returns [AntlrDatatypeRuleToken current=new AntlrDatatype | |||
1723 | ; | 2135 | ; |
1724 | 2136 | ||
1725 | // Entry rule entryRuleQualifiedName | 2137 | // Entry rule entryRuleQualifiedName |
1726 | entryRuleQualifiedName returns [String current=null]: | 2138 | entryRuleQualifiedName returns [String current=null]@init { |
2139 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
2140 | }: | ||
1727 | { newCompositeNode(grammarAccess.getQualifiedNameRule()); } | 2141 | { newCompositeNode(grammarAccess.getQualifiedNameRule()); } |
1728 | iv_ruleQualifiedName=ruleQualifiedName | 2142 | iv_ruleQualifiedName=ruleQualifiedName |
1729 | { $current=$iv_ruleQualifiedName.current.getText(); } | 2143 | { $current=$iv_ruleQualifiedName.current.getText(); } |
1730 | EOF; | 2144 | EOF; |
2145 | finally { | ||
2146 | myHiddenTokenState.restore(); | ||
2147 | } | ||
1731 | 2148 | ||
1732 | // Rule QualifiedName | 2149 | // Rule QualifiedName |
1733 | ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] | 2150 | ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] |
1734 | @init { | 2151 | @init { |
1735 | enterRule(); | 2152 | enterRule(); |
2153 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
1736 | } | 2154 | } |
1737 | @after { | 2155 | @after { |
1738 | leaveRule(); | 2156 | leaveRule(); |
@@ -1791,6 +2209,9 @@ ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleT | |||
1791 | ) | 2209 | ) |
1792 | ) | 2210 | ) |
1793 | ; | 2211 | ; |
2212 | finally { | ||
2213 | myHiddenTokenState.restore(); | ||
2214 | } | ||
1794 | 2215 | ||
1795 | // Entry rule entryRuleIdentifier | 2216 | // Entry rule entryRuleIdentifier |
1796 | entryRuleIdentifier returns [String current=null]: | 2217 | entryRuleIdentifier returns [String current=null]: |
@@ -1827,9 +2248,171 @@ ruleIdentifier returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToke | |||
1827 | $current.merge(kw); | 2248 | $current.merge(kw); |
1828 | newLeafNode(kw, grammarAccess.getIdentifierAccess().getFalseKeyword_2()); | 2249 | newLeafNode(kw, grammarAccess.getIdentifierAccess().getFalseKeyword_2()); |
1829 | } | 2250 | } |
2251 | | | ||
2252 | kw='e' | ||
2253 | { | ||
2254 | $current.merge(kw); | ||
2255 | newLeafNode(kw, grammarAccess.getIdentifierAccess().getEKeyword_3()); | ||
2256 | } | ||
2257 | | | ||
2258 | kw='E' | ||
2259 | { | ||
2260 | $current.merge(kw); | ||
2261 | newLeafNode(kw, grammarAccess.getIdentifierAccess().getEKeyword_4()); | ||
2262 | } | ||
1830 | ) | 2263 | ) |
1831 | ; | 2264 | ; |
1832 | 2265 | ||
2266 | // Entry rule entryRuleInteger | ||
2267 | entryRuleInteger returns [String current=null]@init { | ||
2268 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
2269 | }: | ||
2270 | { newCompositeNode(grammarAccess.getIntegerRule()); } | ||
2271 | iv_ruleInteger=ruleInteger | ||
2272 | { $current=$iv_ruleInteger.current.getText(); } | ||
2273 | EOF; | ||
2274 | finally { | ||
2275 | myHiddenTokenState.restore(); | ||
2276 | } | ||
2277 | |||
2278 | // Rule Integer | ||
2279 | ruleInteger returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] | ||
2280 | @init { | ||
2281 | enterRule(); | ||
2282 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
2283 | } | ||
2284 | @after { | ||
2285 | leaveRule(); | ||
2286 | }: | ||
2287 | ( | ||
2288 | ( | ||
2289 | kw='-' | ||
2290 | { | ||
2291 | $current.merge(kw); | ||
2292 | newLeafNode(kw, grammarAccess.getIntegerAccess().getHyphenMinusKeyword_0()); | ||
2293 | } | ||
2294 | )? | ||
2295 | this_INT_1=RULE_INT | ||
2296 | { | ||
2297 | $current.merge(this_INT_1); | ||
2298 | } | ||
2299 | { | ||
2300 | newLeafNode(this_INT_1, grammarAccess.getIntegerAccess().getINTTerminalRuleCall_1()); | ||
2301 | } | ||
2302 | ) | ||
2303 | ; | ||
2304 | finally { | ||
2305 | myHiddenTokenState.restore(); | ||
2306 | } | ||
2307 | |||
2308 | // Entry rule entryRuleReal | ||
2309 | entryRuleReal returns [String current=null]@init { | ||
2310 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
2311 | }: | ||
2312 | { newCompositeNode(grammarAccess.getRealRule()); } | ||
2313 | iv_ruleReal=ruleReal | ||
2314 | { $current=$iv_ruleReal.current.getText(); } | ||
2315 | EOF; | ||
2316 | finally { | ||
2317 | myHiddenTokenState.restore(); | ||
2318 | } | ||
2319 | |||
2320 | // Rule Real | ||
2321 | ruleReal returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] | ||
2322 | @init { | ||
2323 | enterRule(); | ||
2324 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
2325 | } | ||
2326 | @after { | ||
2327 | leaveRule(); | ||
2328 | }: | ||
2329 | ( | ||
2330 | ( | ||
2331 | kw='-' | ||
2332 | { | ||
2333 | $current.merge(kw); | ||
2334 | newLeafNode(kw, grammarAccess.getRealAccess().getHyphenMinusKeyword_0()); | ||
2335 | } | ||
2336 | )? | ||
2337 | this_INT_1=RULE_INT | ||
2338 | { | ||
2339 | $current.merge(this_INT_1); | ||
2340 | } | ||
2341 | { | ||
2342 | newLeafNode(this_INT_1, grammarAccess.getRealAccess().getINTTerminalRuleCall_1()); | ||
2343 | } | ||
2344 | ( | ||
2345 | ( | ||
2346 | kw='.' | ||
2347 | { | ||
2348 | $current.merge(kw); | ||
2349 | newLeafNode(kw, grammarAccess.getRealAccess().getFullStopKeyword_2_0_0()); | ||
2350 | } | ||
2351 | this_INT_3=RULE_INT | ||
2352 | { | ||
2353 | $current.merge(this_INT_3); | ||
2354 | } | ||
2355 | { | ||
2356 | newLeafNode(this_INT_3, grammarAccess.getRealAccess().getINTTerminalRuleCall_2_0_1()); | ||
2357 | } | ||
2358 | ) | ||
2359 | | | ||
2360 | ( | ||
2361 | ( | ||
2362 | kw='.' | ||
2363 | { | ||
2364 | $current.merge(kw); | ||
2365 | newLeafNode(kw, grammarAccess.getRealAccess().getFullStopKeyword_2_1_0_0()); | ||
2366 | } | ||
2367 | this_INT_5=RULE_INT | ||
2368 | { | ||
2369 | $current.merge(this_INT_5); | ||
2370 | } | ||
2371 | { | ||
2372 | newLeafNode(this_INT_5, grammarAccess.getRealAccess().getINTTerminalRuleCall_2_1_0_1()); | ||
2373 | } | ||
2374 | )? | ||
2375 | ( | ||
2376 | kw='e' | ||
2377 | { | ||
2378 | $current.merge(kw); | ||
2379 | newLeafNode(kw, grammarAccess.getRealAccess().getEKeyword_2_1_1_0()); | ||
2380 | } | ||
2381 | | | ||
2382 | kw='E' | ||
2383 | { | ||
2384 | $current.merge(kw); | ||
2385 | newLeafNode(kw, grammarAccess.getRealAccess().getEKeyword_2_1_1_1()); | ||
2386 | } | ||
2387 | ) | ||
2388 | ( | ||
2389 | kw='-' | ||
2390 | { | ||
2391 | $current.merge(kw); | ||
2392 | newLeafNode(kw, grammarAccess.getRealAccess().getHyphenMinusKeyword_2_1_2_0()); | ||
2393 | } | ||
2394 | | | ||
2395 | kw='+' | ||
2396 | { | ||
2397 | $current.merge(kw); | ||
2398 | newLeafNode(kw, grammarAccess.getRealAccess().getPlusSignKeyword_2_1_2_1()); | ||
2399 | } | ||
2400 | )? | ||
2401 | this_INT_10=RULE_INT | ||
2402 | { | ||
2403 | $current.merge(this_INT_10); | ||
2404 | } | ||
2405 | { | ||
2406 | newLeafNode(this_INT_10, grammarAccess.getRealAccess().getINTTerminalRuleCall_2_1_3()); | ||
2407 | } | ||
2408 | ) | ||
2409 | ) | ||
2410 | ) | ||
2411 | ; | ||
2412 | finally { | ||
2413 | myHiddenTokenState.restore(); | ||
2414 | } | ||
2415 | |||
1833 | // Rule LogicValue | 2416 | // Rule LogicValue |
1834 | ruleLogicValue returns [Enumerator current=null] | 2417 | ruleLogicValue returns [Enumerator current=null] |
1835 | @init { | 2418 | @init { |
@@ -1892,14 +2475,14 @@ ruleShortLogicValue returns [Enumerator current=null] | |||
1892 | ) | 2475 | ) |
1893 | ; | 2476 | ; |
1894 | 2477 | ||
2478 | RULE_ID : ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; | ||
2479 | |||
1895 | RULE_STRING : '"' ('\\' .|~(('\\'|'"')))* '"'; | 2480 | RULE_STRING : '"' ('\\' .|~(('\\'|'"')))* '"'; |
1896 | 2481 | ||
1897 | RULE_QUOTED_ID : '\'' ('\\' .|~(('\\'|'\'')))* '\''; | 2482 | RULE_QUOTED_ID : '\'' ('\\' .|~(('\\'|'\'')))* '\''; |
1898 | 2483 | ||
1899 | RULE_SL_COMMENT : ('%'|'//') ~(('\n'|'\r'))* ('\r'? '\n')?; | 2484 | RULE_SL_COMMENT : ('%'|'//') ~(('\n'|'\r'))* ('\r'? '\n')?; |
1900 | 2485 | ||
1901 | RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; | ||
1902 | |||
1903 | RULE_INT : ('0'..'9')+; | 2486 | RULE_INT : ('0'..'9')+; |
1904 | 2487 | ||
1905 | RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; | 2488 | RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; |
diff --git a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblem.tokens b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblem.tokens index 7b308424..763a9cc8 100644 --- a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblem.tokens +++ b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblem.tokens | |||
@@ -5,6 +5,7 @@ | |||
5 | '+'=33 | 5 | '+'=33 |
6 | '+='=36 | 6 | '+='=36 |
7 | ','=17 | 7 | ','=17 |
8 | '-'=45 | ||
8 | '.'=13 | 9 | '.'=13 |
9 | '..'=38 | 10 | '..'=38 |
10 | ':'=34 | 11 | ':'=34 |
@@ -12,12 +13,14 @@ | |||
12 | '::'=40 | 13 | '::'=40 |
13 | ';'=19 | 14 | ';'=19 |
14 | '='=37 | 15 | '='=37 |
15 | '?'=44 | 16 | '?'=47 |
17 | 'E'=44 | ||
16 | '['=24 | 18 | '['=24 |
17 | ']'=25 | 19 | ']'=25 |
18 | 'abstract'=14 | 20 | 'abstract'=14 |
19 | 'class'=15 | 21 | 'class'=15 |
20 | 'contains'=22 | 22 | 'contains'=22 |
23 | 'e'=43 | ||
21 | 'enum'=21 | 24 | 'enum'=21 |
22 | 'error'=27 | 25 | 'error'=27 |
23 | 'extends'=16 | 26 | 'extends'=16 |
@@ -28,16 +31,16 @@ | |||
28 | 'refers'=23 | 31 | 'refers'=23 |
29 | 'scope'=35 | 32 | 'scope'=35 |
30 | 'true'=41 | 33 | 'true'=41 |
31 | 'unknown'=43 | 34 | 'unknown'=46 |
32 | '{'=18 | 35 | '{'=18 |
33 | '}'=20 | 36 | '}'=20 |
34 | RULE_ANY_OTHER=11 | 37 | RULE_ANY_OTHER=11 |
35 | RULE_ID=4 | 38 | RULE_ID=5 |
36 | RULE_INT=5 | 39 | RULE_INT=6 |
37 | RULE_ML_COMMENT=9 | 40 | RULE_ML_COMMENT=9 |
38 | RULE_QUOTED_ID=6 | 41 | RULE_QUOTED_ID=7 |
39 | RULE_SL_COMMENT=8 | 42 | RULE_SL_COMMENT=8 |
40 | RULE_STRING=7 | 43 | RULE_STRING=4 |
41 | RULE_WS=10 | 44 | RULE_WS=10 |
42 | T__12=12 | 45 | T__12=12 |
43 | T__13=13 | 46 | T__13=13 |
@@ -72,3 +75,6 @@ T__41=41 | |||
72 | T__42=42 | 75 | T__42=42 |
73 | T__43=43 | 76 | T__43=43 |
74 | T__44=44 | 77 | T__44=44 |
78 | T__45=45 | ||
79 | T__46=46 | ||
80 | T__47=47 | ||
diff --git a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblemLexer.java b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblemLexer.java index c6298afc..345610ce 100644 --- a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblemLexer.java +++ b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblemLexer.java | |||
@@ -20,12 +20,12 @@ public class InternalProblemLexer extends Lexer { | |||
20 | public static final int T__12=12; | 20 | public static final int T__12=12; |
21 | public static final int T__13=13; | 21 | public static final int T__13=13; |
22 | public static final int T__14=14; | 22 | public static final int T__14=14; |
23 | public static final int RULE_ID=4; | 23 | public static final int RULE_ID=5; |
24 | public static final int RULE_QUOTED_ID=6; | 24 | public static final int RULE_QUOTED_ID=7; |
25 | public static final int T__26=26; | 25 | public static final int T__26=26; |
26 | public static final int T__27=27; | 26 | public static final int T__27=27; |
27 | public static final int T__28=28; | 27 | public static final int T__28=28; |
28 | public static final int RULE_INT=5; | 28 | public static final int RULE_INT=6; |
29 | public static final int T__29=29; | 29 | public static final int T__29=29; |
30 | public static final int T__22=22; | 30 | public static final int T__22=22; |
31 | public static final int RULE_ML_COMMENT=9; | 31 | public static final int RULE_ML_COMMENT=9; |
@@ -34,7 +34,7 @@ public class InternalProblemLexer extends Lexer { | |||
34 | public static final int T__25=25; | 34 | public static final int T__25=25; |
35 | public static final int T__20=20; | 35 | public static final int T__20=20; |
36 | public static final int T__21=21; | 36 | public static final int T__21=21; |
37 | public static final int RULE_STRING=7; | 37 | public static final int RULE_STRING=4; |
38 | public static final int RULE_SL_COMMENT=8; | 38 | public static final int RULE_SL_COMMENT=8; |
39 | public static final int T__37=37; | 39 | public static final int T__37=37; |
40 | public static final int T__38=38; | 40 | public static final int T__38=38; |
@@ -50,6 +50,9 @@ public class InternalProblemLexer extends Lexer { | |||
50 | public static final int RULE_WS=10; | 50 | public static final int RULE_WS=10; |
51 | public static final int RULE_ANY_OTHER=11; | 51 | public static final int RULE_ANY_OTHER=11; |
52 | public static final int T__44=44; | 52 | public static final int T__44=44; |
53 | public static final int T__45=45; | ||
54 | public static final int T__46=46; | ||
55 | public static final int T__47=47; | ||
53 | public static final int T__40=40; | 56 | public static final int T__40=40; |
54 | public static final int T__41=41; | 57 | public static final int T__41=41; |
55 | public static final int T__42=42; | 58 | public static final int T__42=42; |
@@ -710,11 +713,10 @@ public class InternalProblemLexer extends Lexer { | |||
710 | try { | 713 | try { |
711 | int _type = T__43; | 714 | int _type = T__43; |
712 | int _channel = DEFAULT_TOKEN_CHANNEL; | 715 | int _channel = DEFAULT_TOKEN_CHANNEL; |
713 | // InternalProblem.g:42:7: ( 'unknown' ) | 716 | // InternalProblem.g:42:7: ( 'e' ) |
714 | // InternalProblem.g:42:9: 'unknown' | 717 | // InternalProblem.g:42:9: 'e' |
715 | { | 718 | { |
716 | match("unknown"); | 719 | match('e'); |
717 | |||
718 | 720 | ||
719 | } | 721 | } |
720 | 722 | ||
@@ -731,10 +733,10 @@ public class InternalProblemLexer extends Lexer { | |||
731 | try { | 733 | try { |
732 | int _type = T__44; | 734 | int _type = T__44; |
733 | int _channel = DEFAULT_TOKEN_CHANNEL; | 735 | int _channel = DEFAULT_TOKEN_CHANNEL; |
734 | // InternalProblem.g:43:7: ( '?' ) | 736 | // InternalProblem.g:43:7: ( 'E' ) |
735 | // InternalProblem.g:43:9: '?' | 737 | // InternalProblem.g:43:9: 'E' |
736 | { | 738 | { |
737 | match('?'); | 739 | match('E'); |
738 | 740 | ||
739 | } | 741 | } |
740 | 742 | ||
@@ -746,32 +748,154 @@ public class InternalProblemLexer extends Lexer { | |||
746 | } | 748 | } |
747 | // $ANTLR end "T__44" | 749 | // $ANTLR end "T__44" |
748 | 750 | ||
751 | // $ANTLR start "T__45" | ||
752 | public final void mT__45() throws RecognitionException { | ||
753 | try { | ||
754 | int _type = T__45; | ||
755 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
756 | // InternalProblem.g:44:7: ( '-' ) | ||
757 | // InternalProblem.g:44:9: '-' | ||
758 | { | ||
759 | match('-'); | ||
760 | |||
761 | } | ||
762 | |||
763 | state.type = _type; | ||
764 | state.channel = _channel; | ||
765 | } | ||
766 | finally { | ||
767 | } | ||
768 | } | ||
769 | // $ANTLR end "T__45" | ||
770 | |||
771 | // $ANTLR start "T__46" | ||
772 | public final void mT__46() throws RecognitionException { | ||
773 | try { | ||
774 | int _type = T__46; | ||
775 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
776 | // InternalProblem.g:45:7: ( 'unknown' ) | ||
777 | // InternalProblem.g:45:9: 'unknown' | ||
778 | { | ||
779 | match("unknown"); | ||
780 | |||
781 | |||
782 | } | ||
783 | |||
784 | state.type = _type; | ||
785 | state.channel = _channel; | ||
786 | } | ||
787 | finally { | ||
788 | } | ||
789 | } | ||
790 | // $ANTLR end "T__46" | ||
791 | |||
792 | // $ANTLR start "T__47" | ||
793 | public final void mT__47() throws RecognitionException { | ||
794 | try { | ||
795 | int _type = T__47; | ||
796 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
797 | // InternalProblem.g:46:7: ( '?' ) | ||
798 | // InternalProblem.g:46:9: '?' | ||
799 | { | ||
800 | match('?'); | ||
801 | |||
802 | } | ||
803 | |||
804 | state.type = _type; | ||
805 | state.channel = _channel; | ||
806 | } | ||
807 | finally { | ||
808 | } | ||
809 | } | ||
810 | // $ANTLR end "T__47" | ||
811 | |||
812 | // $ANTLR start "RULE_ID" | ||
813 | public final void mRULE_ID() throws RecognitionException { | ||
814 | try { | ||
815 | int _type = RULE_ID; | ||
816 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
817 | // InternalProblem.g:2478:9: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) | ||
818 | // InternalProblem.g:2478:11: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | ||
819 | { | ||
820 | if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { | ||
821 | input.consume(); | ||
822 | |||
823 | } | ||
824 | else { | ||
825 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
826 | recover(mse); | ||
827 | throw mse;} | ||
828 | |||
829 | // InternalProblem.g:2478:35: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | ||
830 | loop1: | ||
831 | do { | ||
832 | int alt1=2; | ||
833 | int LA1_0 = input.LA(1); | ||
834 | |||
835 | if ( ((LA1_0>='0' && LA1_0<='9')||(LA1_0>='A' && LA1_0<='Z')||LA1_0=='_'||(LA1_0>='a' && LA1_0<='z')) ) { | ||
836 | alt1=1; | ||
837 | } | ||
838 | |||
839 | |||
840 | switch (alt1) { | ||
841 | case 1 : | ||
842 | // InternalProblem.g: | ||
843 | { | ||
844 | if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { | ||
845 | input.consume(); | ||
846 | |||
847 | } | ||
848 | else { | ||
849 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
850 | recover(mse); | ||
851 | throw mse;} | ||
852 | |||
853 | |||
854 | } | ||
855 | break; | ||
856 | |||
857 | default : | ||
858 | break loop1; | ||
859 | } | ||
860 | } while (true); | ||
861 | |||
862 | |||
863 | } | ||
864 | |||
865 | state.type = _type; | ||
866 | state.channel = _channel; | ||
867 | } | ||
868 | finally { | ||
869 | } | ||
870 | } | ||
871 | // $ANTLR end "RULE_ID" | ||
872 | |||
749 | // $ANTLR start "RULE_STRING" | 873 | // $ANTLR start "RULE_STRING" |
750 | public final void mRULE_STRING() throws RecognitionException { | 874 | public final void mRULE_STRING() throws RecognitionException { |
751 | try { | 875 | try { |
752 | int _type = RULE_STRING; | 876 | int _type = RULE_STRING; |
753 | int _channel = DEFAULT_TOKEN_CHANNEL; | 877 | int _channel = DEFAULT_TOKEN_CHANNEL; |
754 | // InternalProblem.g:1895:13: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' ) | 878 | // InternalProblem.g:2480:13: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' ) |
755 | // InternalProblem.g:1895:15: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | 879 | // InternalProblem.g:2480:15: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' |
756 | { | 880 | { |
757 | match('\"'); | 881 | match('\"'); |
758 | // InternalProblem.g:1895:19: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* | 882 | // InternalProblem.g:2480:19: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* |
759 | loop1: | 883 | loop2: |
760 | do { | 884 | do { |
761 | int alt1=3; | 885 | int alt2=3; |
762 | int LA1_0 = input.LA(1); | 886 | int LA2_0 = input.LA(1); |
763 | 887 | ||
764 | if ( (LA1_0=='\\') ) { | 888 | if ( (LA2_0=='\\') ) { |
765 | alt1=1; | 889 | alt2=1; |
766 | } | 890 | } |
767 | else if ( ((LA1_0>='\u0000' && LA1_0<='!')||(LA1_0>='#' && LA1_0<='[')||(LA1_0>=']' && LA1_0<='\uFFFF')) ) { | 891 | else if ( ((LA2_0>='\u0000' && LA2_0<='!')||(LA2_0>='#' && LA2_0<='[')||(LA2_0>=']' && LA2_0<='\uFFFF')) ) { |
768 | alt1=2; | 892 | alt2=2; |
769 | } | 893 | } |
770 | 894 | ||
771 | 895 | ||
772 | switch (alt1) { | 896 | switch (alt2) { |
773 | case 1 : | 897 | case 1 : |
774 | // InternalProblem.g:1895:20: '\\\\' . | 898 | // InternalProblem.g:2480:20: '\\\\' . |
775 | { | 899 | { |
776 | match('\\'); | 900 | match('\\'); |
777 | matchAny(); | 901 | matchAny(); |
@@ -779,7 +903,7 @@ public class InternalProblemLexer extends Lexer { | |||
779 | } | 903 | } |
780 | break; | 904 | break; |
781 | case 2 : | 905 | case 2 : |
782 | // InternalProblem.g:1895:27: ~ ( ( '\\\\' | '\"' ) ) | 906 | // InternalProblem.g:2480:27: ~ ( ( '\\\\' | '\"' ) ) |
783 | { | 907 | { |
784 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { | 908 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { |
785 | input.consume(); | 909 | input.consume(); |
@@ -795,7 +919,7 @@ public class InternalProblemLexer extends Lexer { | |||
795 | break; | 919 | break; |
796 | 920 | ||
797 | default : | 921 | default : |
798 | break loop1; | 922 | break loop2; |
799 | } | 923 | } |
800 | } while (true); | 924 | } while (true); |
801 | 925 | ||
@@ -816,27 +940,27 @@ public class InternalProblemLexer extends Lexer { | |||
816 | try { | 940 | try { |
817 | int _type = RULE_QUOTED_ID; | 941 | int _type = RULE_QUOTED_ID; |
818 | int _channel = DEFAULT_TOKEN_CHANNEL; | 942 | int _channel = DEFAULT_TOKEN_CHANNEL; |
819 | // InternalProblem.g:1897:16: ( '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) | 943 | // InternalProblem.g:2482:16: ( '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) |
820 | // InternalProblem.g:1897:18: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' | 944 | // InternalProblem.g:2482:18: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' |
821 | { | 945 | { |
822 | match('\''); | 946 | match('\''); |
823 | // InternalProblem.g:1897:23: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* | 947 | // InternalProblem.g:2482:23: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* |
824 | loop2: | 948 | loop3: |
825 | do { | 949 | do { |
826 | int alt2=3; | 950 | int alt3=3; |
827 | int LA2_0 = input.LA(1); | 951 | int LA3_0 = input.LA(1); |
828 | 952 | ||
829 | if ( (LA2_0=='\\') ) { | 953 | if ( (LA3_0=='\\') ) { |
830 | alt2=1; | 954 | alt3=1; |
831 | } | 955 | } |
832 | else if ( ((LA2_0>='\u0000' && LA2_0<='&')||(LA2_0>='(' && LA2_0<='[')||(LA2_0>=']' && LA2_0<='\uFFFF')) ) { | 956 | else if ( ((LA3_0>='\u0000' && LA3_0<='&')||(LA3_0>='(' && LA3_0<='[')||(LA3_0>=']' && LA3_0<='\uFFFF')) ) { |
833 | alt2=2; | 957 | alt3=2; |
834 | } | 958 | } |
835 | 959 | ||
836 | 960 | ||
837 | switch (alt2) { | 961 | switch (alt3) { |
838 | case 1 : | 962 | case 1 : |
839 | // InternalProblem.g:1897:24: '\\\\' . | 963 | // InternalProblem.g:2482:24: '\\\\' . |
840 | { | 964 | { |
841 | match('\\'); | 965 | match('\\'); |
842 | matchAny(); | 966 | matchAny(); |
@@ -844,7 +968,7 @@ public class InternalProblemLexer extends Lexer { | |||
844 | } | 968 | } |
845 | break; | 969 | break; |
846 | case 2 : | 970 | case 2 : |
847 | // InternalProblem.g:1897:31: ~ ( ( '\\\\' | '\\'' ) ) | 971 | // InternalProblem.g:2482:31: ~ ( ( '\\\\' | '\\'' ) ) |
848 | { | 972 | { |
849 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { | 973 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { |
850 | input.consume(); | 974 | input.consume(); |
@@ -860,7 +984,7 @@ public class InternalProblemLexer extends Lexer { | |||
860 | break; | 984 | break; |
861 | 985 | ||
862 | default : | 986 | default : |
863 | break loop2; | 987 | break loop3; |
864 | } | 988 | } |
865 | } while (true); | 989 | } while (true); |
866 | 990 | ||
@@ -881,35 +1005,35 @@ public class InternalProblemLexer extends Lexer { | |||
881 | try { | 1005 | try { |
882 | int _type = RULE_SL_COMMENT; | 1006 | int _type = RULE_SL_COMMENT; |
883 | int _channel = DEFAULT_TOKEN_CHANNEL; | 1007 | int _channel = DEFAULT_TOKEN_CHANNEL; |
884 | // InternalProblem.g:1899:17: ( ( '%' | '//' ) (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) | 1008 | // InternalProblem.g:2484:17: ( ( '%' | '//' ) (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) |
885 | // InternalProblem.g:1899:19: ( '%' | '//' ) (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? | 1009 | // InternalProblem.g:2484:19: ( '%' | '//' ) (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? |
886 | { | 1010 | { |
887 | // InternalProblem.g:1899:19: ( '%' | '//' ) | 1011 | // InternalProblem.g:2484:19: ( '%' | '//' ) |
888 | int alt3=2; | 1012 | int alt4=2; |
889 | int LA3_0 = input.LA(1); | 1013 | int LA4_0 = input.LA(1); |
890 | 1014 | ||
891 | if ( (LA3_0=='%') ) { | 1015 | if ( (LA4_0=='%') ) { |
892 | alt3=1; | 1016 | alt4=1; |
893 | } | 1017 | } |
894 | else if ( (LA3_0=='/') ) { | 1018 | else if ( (LA4_0=='/') ) { |
895 | alt3=2; | 1019 | alt4=2; |
896 | } | 1020 | } |
897 | else { | 1021 | else { |
898 | NoViableAltException nvae = | 1022 | NoViableAltException nvae = |
899 | new NoViableAltException("", 3, 0, input); | 1023 | new NoViableAltException("", 4, 0, input); |
900 | 1024 | ||
901 | throw nvae; | 1025 | throw nvae; |
902 | } | 1026 | } |
903 | switch (alt3) { | 1027 | switch (alt4) { |
904 | case 1 : | 1028 | case 1 : |
905 | // InternalProblem.g:1899:20: '%' | 1029 | // InternalProblem.g:2484:20: '%' |
906 | { | 1030 | { |
907 | match('%'); | 1031 | match('%'); |
908 | 1032 | ||
909 | } | 1033 | } |
910 | break; | 1034 | break; |
911 | case 2 : | 1035 | case 2 : |
912 | // InternalProblem.g:1899:24: '//' | 1036 | // InternalProblem.g:2484:24: '//' |
913 | { | 1037 | { |
914 | match("//"); | 1038 | match("//"); |
915 | 1039 | ||
@@ -919,20 +1043,20 @@ public class InternalProblemLexer extends Lexer { | |||
919 | 1043 | ||
920 | } | 1044 | } |
921 | 1045 | ||
922 | // InternalProblem.g:1899:30: (~ ( ( '\\n' | '\\r' ) ) )* | 1046 | // InternalProblem.g:2484:30: (~ ( ( '\\n' | '\\r' ) ) )* |
923 | loop4: | 1047 | loop5: |
924 | do { | 1048 | do { |
925 | int alt4=2; | 1049 | int alt5=2; |
926 | int LA4_0 = input.LA(1); | 1050 | int LA5_0 = input.LA(1); |
927 | 1051 | ||
928 | if ( ((LA4_0>='\u0000' && LA4_0<='\t')||(LA4_0>='\u000B' && LA4_0<='\f')||(LA4_0>='\u000E' && LA4_0<='\uFFFF')) ) { | 1052 | if ( ((LA5_0>='\u0000' && LA5_0<='\t')||(LA5_0>='\u000B' && LA5_0<='\f')||(LA5_0>='\u000E' && LA5_0<='\uFFFF')) ) { |
929 | alt4=1; | 1053 | alt5=1; |
930 | } | 1054 | } |
931 | 1055 | ||
932 | 1056 | ||
933 | switch (alt4) { | 1057 | switch (alt5) { |
934 | case 1 : | 1058 | case 1 : |
935 | // InternalProblem.g:1899:30: ~ ( ( '\\n' | '\\r' ) ) | 1059 | // InternalProblem.g:2484:30: ~ ( ( '\\n' | '\\r' ) ) |
936 | { | 1060 | { |
937 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) { | 1061 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) { |
938 | input.consume(); | 1062 | input.consume(); |
@@ -948,31 +1072,31 @@ public class InternalProblemLexer extends Lexer { | |||
948 | break; | 1072 | break; |
949 | 1073 | ||
950 | default : | 1074 | default : |
951 | break loop4; | 1075 | break loop5; |
952 | } | 1076 | } |
953 | } while (true); | 1077 | } while (true); |
954 | 1078 | ||
955 | // InternalProblem.g:1899:46: ( ( '\\r' )? '\\n' )? | 1079 | // InternalProblem.g:2484:46: ( ( '\\r' )? '\\n' )? |
956 | int alt6=2; | 1080 | int alt7=2; |
957 | int LA6_0 = input.LA(1); | 1081 | int LA7_0 = input.LA(1); |
958 | 1082 | ||
959 | if ( (LA6_0=='\n'||LA6_0=='\r') ) { | 1083 | if ( (LA7_0=='\n'||LA7_0=='\r') ) { |
960 | alt6=1; | 1084 | alt7=1; |
961 | } | 1085 | } |
962 | switch (alt6) { | 1086 | switch (alt7) { |
963 | case 1 : | 1087 | case 1 : |
964 | // InternalProblem.g:1899:47: ( '\\r' )? '\\n' | 1088 | // InternalProblem.g:2484:47: ( '\\r' )? '\\n' |
965 | { | 1089 | { |
966 | // InternalProblem.g:1899:47: ( '\\r' )? | 1090 | // InternalProblem.g:2484:47: ( '\\r' )? |
967 | int alt5=2; | 1091 | int alt6=2; |
968 | int LA5_0 = input.LA(1); | 1092 | int LA6_0 = input.LA(1); |
969 | 1093 | ||
970 | if ( (LA5_0=='\r') ) { | 1094 | if ( (LA6_0=='\r') ) { |
971 | alt5=1; | 1095 | alt6=1; |
972 | } | 1096 | } |
973 | switch (alt5) { | 1097 | switch (alt6) { |
974 | case 1 : | 1098 | case 1 : |
975 | // InternalProblem.g:1899:47: '\\r' | 1099 | // InternalProblem.g:2484:47: '\\r' |
976 | { | 1100 | { |
977 | match('\r'); | 1101 | match('\r'); |
978 | 1102 | ||
@@ -999,108 +1123,29 @@ public class InternalProblemLexer extends Lexer { | |||
999 | } | 1123 | } |
1000 | // $ANTLR end "RULE_SL_COMMENT" | 1124 | // $ANTLR end "RULE_SL_COMMENT" |
1001 | 1125 | ||
1002 | // $ANTLR start "RULE_ID" | 1126 | // $ANTLR start "RULE_INT" |
1003 | public final void mRULE_ID() throws RecognitionException { | 1127 | public final void mRULE_INT() throws RecognitionException { |
1004 | try { | 1128 | try { |
1005 | int _type = RULE_ID; | 1129 | int _type = RULE_INT; |
1006 | int _channel = DEFAULT_TOKEN_CHANNEL; | 1130 | int _channel = DEFAULT_TOKEN_CHANNEL; |
1007 | // InternalProblem.g:1901:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) | 1131 | // InternalProblem.g:2486:10: ( ( '0' .. '9' )+ ) |
1008 | // InternalProblem.g:1901:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | 1132 | // InternalProblem.g:2486:12: ( '0' .. '9' )+ |
1009 | { | 1133 | { |
1010 | // InternalProblem.g:1901:11: ( '^' )? | 1134 | // InternalProblem.g:2486:12: ( '0' .. '9' )+ |
1011 | int alt7=2; | 1135 | int cnt8=0; |
1012 | int LA7_0 = input.LA(1); | ||
1013 | |||
1014 | if ( (LA7_0=='^') ) { | ||
1015 | alt7=1; | ||
1016 | } | ||
1017 | switch (alt7) { | ||
1018 | case 1 : | ||
1019 | // InternalProblem.g:1901:11: '^' | ||
1020 | { | ||
1021 | match('^'); | ||
1022 | |||
1023 | } | ||
1024 | break; | ||
1025 | |||
1026 | } | ||
1027 | |||
1028 | if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { | ||
1029 | input.consume(); | ||
1030 | |||
1031 | } | ||
1032 | else { | ||
1033 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1034 | recover(mse); | ||
1035 | throw mse;} | ||
1036 | |||
1037 | // InternalProblem.g:1901:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | ||
1038 | loop8: | 1136 | loop8: |
1039 | do { | 1137 | do { |
1040 | int alt8=2; | 1138 | int alt8=2; |
1041 | int LA8_0 = input.LA(1); | 1139 | int LA8_0 = input.LA(1); |
1042 | 1140 | ||
1043 | if ( ((LA8_0>='0' && LA8_0<='9')||(LA8_0>='A' && LA8_0<='Z')||LA8_0=='_'||(LA8_0>='a' && LA8_0<='z')) ) { | 1141 | if ( ((LA8_0>='0' && LA8_0<='9')) ) { |
1044 | alt8=1; | 1142 | alt8=1; |
1045 | } | 1143 | } |
1046 | 1144 | ||
1047 | 1145 | ||
1048 | switch (alt8) { | 1146 | switch (alt8) { |
1049 | case 1 : | 1147 | case 1 : |
1050 | // InternalProblem.g: | 1148 | // InternalProblem.g:2486:13: '0' .. '9' |
1051 | { | ||
1052 | if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { | ||
1053 | input.consume(); | ||
1054 | |||
1055 | } | ||
1056 | else { | ||
1057 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1058 | recover(mse); | ||
1059 | throw mse;} | ||
1060 | |||
1061 | |||
1062 | } | ||
1063 | break; | ||
1064 | |||
1065 | default : | ||
1066 | break loop8; | ||
1067 | } | ||
1068 | } while (true); | ||
1069 | |||
1070 | |||
1071 | } | ||
1072 | |||
1073 | state.type = _type; | ||
1074 | state.channel = _channel; | ||
1075 | } | ||
1076 | finally { | ||
1077 | } | ||
1078 | } | ||
1079 | // $ANTLR end "RULE_ID" | ||
1080 | |||
1081 | // $ANTLR start "RULE_INT" | ||
1082 | public final void mRULE_INT() throws RecognitionException { | ||
1083 | try { | ||
1084 | int _type = RULE_INT; | ||
1085 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1086 | // InternalProblem.g:1903:10: ( ( '0' .. '9' )+ ) | ||
1087 | // InternalProblem.g:1903:12: ( '0' .. '9' )+ | ||
1088 | { | ||
1089 | // InternalProblem.g:1903:12: ( '0' .. '9' )+ | ||
1090 | int cnt9=0; | ||
1091 | loop9: | ||
1092 | do { | ||
1093 | int alt9=2; | ||
1094 | int LA9_0 = input.LA(1); | ||
1095 | |||
1096 | if ( ((LA9_0>='0' && LA9_0<='9')) ) { | ||
1097 | alt9=1; | ||
1098 | } | ||
1099 | |||
1100 | |||
1101 | switch (alt9) { | ||
1102 | case 1 : | ||
1103 | // InternalProblem.g:1903:13: '0' .. '9' | ||
1104 | { | 1149 | { |
1105 | matchRange('0','9'); | 1150 | matchRange('0','9'); |
1106 | 1151 | ||
@@ -1108,12 +1153,12 @@ public class InternalProblemLexer extends Lexer { | |||
1108 | break; | 1153 | break; |
1109 | 1154 | ||
1110 | default : | 1155 | default : |
1111 | if ( cnt9 >= 1 ) break loop9; | 1156 | if ( cnt8 >= 1 ) break loop8; |
1112 | EarlyExitException eee = | 1157 | EarlyExitException eee = |
1113 | new EarlyExitException(9, input); | 1158 | new EarlyExitException(8, input); |
1114 | throw eee; | 1159 | throw eee; |
1115 | } | 1160 | } |
1116 | cnt9++; | 1161 | cnt8++; |
1117 | } while (true); | 1162 | } while (true); |
1118 | 1163 | ||
1119 | 1164 | ||
@@ -1132,37 +1177,37 @@ public class InternalProblemLexer extends Lexer { | |||
1132 | try { | 1177 | try { |
1133 | int _type = RULE_ML_COMMENT; | 1178 | int _type = RULE_ML_COMMENT; |
1134 | int _channel = DEFAULT_TOKEN_CHANNEL; | 1179 | int _channel = DEFAULT_TOKEN_CHANNEL; |
1135 | // InternalProblem.g:1905:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) | 1180 | // InternalProblem.g:2488:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) |
1136 | // InternalProblem.g:1905:19: '/*' ( options {greedy=false; } : . )* '*/' | 1181 | // InternalProblem.g:2488:19: '/*' ( options {greedy=false; } : . )* '*/' |
1137 | { | 1182 | { |
1138 | match("/*"); | 1183 | match("/*"); |
1139 | 1184 | ||
1140 | // InternalProblem.g:1905:24: ( options {greedy=false; } : . )* | 1185 | // InternalProblem.g:2488:24: ( options {greedy=false; } : . )* |
1141 | loop10: | 1186 | loop9: |
1142 | do { | 1187 | do { |
1143 | int alt10=2; | 1188 | int alt9=2; |
1144 | int LA10_0 = input.LA(1); | 1189 | int LA9_0 = input.LA(1); |
1145 | 1190 | ||
1146 | if ( (LA10_0=='*') ) { | 1191 | if ( (LA9_0=='*') ) { |
1147 | int LA10_1 = input.LA(2); | 1192 | int LA9_1 = input.LA(2); |
1148 | 1193 | ||
1149 | if ( (LA10_1=='/') ) { | 1194 | if ( (LA9_1=='/') ) { |
1150 | alt10=2; | 1195 | alt9=2; |
1151 | } | 1196 | } |
1152 | else if ( ((LA10_1>='\u0000' && LA10_1<='.')||(LA10_1>='0' && LA10_1<='\uFFFF')) ) { | 1197 | else if ( ((LA9_1>='\u0000' && LA9_1<='.')||(LA9_1>='0' && LA9_1<='\uFFFF')) ) { |
1153 | alt10=1; | 1198 | alt9=1; |
1154 | } | 1199 | } |
1155 | 1200 | ||
1156 | 1201 | ||
1157 | } | 1202 | } |
1158 | else if ( ((LA10_0>='\u0000' && LA10_0<=')')||(LA10_0>='+' && LA10_0<='\uFFFF')) ) { | 1203 | else if ( ((LA9_0>='\u0000' && LA9_0<=')')||(LA9_0>='+' && LA9_0<='\uFFFF')) ) { |
1159 | alt10=1; | 1204 | alt9=1; |
1160 | } | 1205 | } |
1161 | 1206 | ||
1162 | 1207 | ||
1163 | switch (alt10) { | 1208 | switch (alt9) { |
1164 | case 1 : | 1209 | case 1 : |
1165 | // InternalProblem.g:1905:52: . | 1210 | // InternalProblem.g:2488:52: . |
1166 | { | 1211 | { |
1167 | matchAny(); | 1212 | matchAny(); |
1168 | 1213 | ||
@@ -1170,7 +1215,7 @@ public class InternalProblemLexer extends Lexer { | |||
1170 | break; | 1215 | break; |
1171 | 1216 | ||
1172 | default : | 1217 | default : |
1173 | break loop10; | 1218 | break loop9; |
1174 | } | 1219 | } |
1175 | } while (true); | 1220 | } while (true); |
1176 | 1221 | ||
@@ -1192,22 +1237,22 @@ public class InternalProblemLexer extends Lexer { | |||
1192 | try { | 1237 | try { |
1193 | int _type = RULE_WS; | 1238 | int _type = RULE_WS; |
1194 | int _channel = DEFAULT_TOKEN_CHANNEL; | 1239 | int _channel = DEFAULT_TOKEN_CHANNEL; |
1195 | // InternalProblem.g:1907:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) | 1240 | // InternalProblem.g:2490:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) |
1196 | // InternalProblem.g:1907:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ | 1241 | // InternalProblem.g:2490:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ |
1197 | { | 1242 | { |
1198 | // InternalProblem.g:1907:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ | 1243 | // InternalProblem.g:2490:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ |
1199 | int cnt11=0; | 1244 | int cnt10=0; |
1200 | loop11: | 1245 | loop10: |
1201 | do { | 1246 | do { |
1202 | int alt11=2; | 1247 | int alt10=2; |
1203 | int LA11_0 = input.LA(1); | 1248 | int LA10_0 = input.LA(1); |
1204 | 1249 | ||
1205 | if ( ((LA11_0>='\t' && LA11_0<='\n')||LA11_0=='\r'||LA11_0==' ') ) { | 1250 | if ( ((LA10_0>='\t' && LA10_0<='\n')||LA10_0=='\r'||LA10_0==' ') ) { |
1206 | alt11=1; | 1251 | alt10=1; |
1207 | } | 1252 | } |
1208 | 1253 | ||
1209 | 1254 | ||
1210 | switch (alt11) { | 1255 | switch (alt10) { |
1211 | case 1 : | 1256 | case 1 : |
1212 | // InternalProblem.g: | 1257 | // InternalProblem.g: |
1213 | { | 1258 | { |
@@ -1225,12 +1270,12 @@ public class InternalProblemLexer extends Lexer { | |||
1225 | break; | 1270 | break; |
1226 | 1271 | ||
1227 | default : | 1272 | default : |
1228 | if ( cnt11 >= 1 ) break loop11; | 1273 | if ( cnt10 >= 1 ) break loop10; |
1229 | EarlyExitException eee = | 1274 | EarlyExitException eee = |
1230 | new EarlyExitException(11, input); | 1275 | new EarlyExitException(10, input); |
1231 | throw eee; | 1276 | throw eee; |
1232 | } | 1277 | } |
1233 | cnt11++; | 1278 | cnt10++; |
1234 | } while (true); | 1279 | } while (true); |
1235 | 1280 | ||
1236 | 1281 | ||
@@ -1249,8 +1294,8 @@ public class InternalProblemLexer extends Lexer { | |||
1249 | try { | 1294 | try { |
1250 | int _type = RULE_ANY_OTHER; | 1295 | int _type = RULE_ANY_OTHER; |
1251 | int _channel = DEFAULT_TOKEN_CHANNEL; | 1296 | int _channel = DEFAULT_TOKEN_CHANNEL; |
1252 | // InternalProblem.g:1909:16: ( . ) | 1297 | // InternalProblem.g:2492:16: ( . ) |
1253 | // InternalProblem.g:1909:18: . | 1298 | // InternalProblem.g:2492:18: . |
1254 | { | 1299 | { |
1255 | matchAny(); | 1300 | matchAny(); |
1256 | 1301 | ||
@@ -1265,10 +1310,10 @@ public class InternalProblemLexer extends Lexer { | |||
1265 | // $ANTLR end "RULE_ANY_OTHER" | 1310 | // $ANTLR end "RULE_ANY_OTHER" |
1266 | 1311 | ||
1267 | public void mTokens() throws RecognitionException { | 1312 | public void mTokens() throws RecognitionException { |
1268 | // InternalProblem.g:1:8: ( T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | RULE_STRING | RULE_QUOTED_ID | RULE_SL_COMMENT | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER ) | 1313 | // InternalProblem.g:1:8: ( T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | RULE_ID | RULE_STRING | RULE_QUOTED_ID | RULE_SL_COMMENT | RULE_INT | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER ) |
1269 | int alt12=41; | 1314 | int alt11=44; |
1270 | alt12 = dfa12.predict(input); | 1315 | alt11 = dfa11.predict(input); |
1271 | switch (alt12) { | 1316 | switch (alt11) { |
1272 | case 1 : | 1317 | case 1 : |
1273 | // InternalProblem.g:1:10: T__12 | 1318 | // InternalProblem.g:1:10: T__12 |
1274 | { | 1319 | { |
@@ -1501,56 +1546,77 @@ public class InternalProblemLexer extends Lexer { | |||
1501 | } | 1546 | } |
1502 | break; | 1547 | break; |
1503 | case 34 : | 1548 | case 34 : |
1504 | // InternalProblem.g:1:208: RULE_STRING | 1549 | // InternalProblem.g:1:208: T__45 |
1505 | { | 1550 | { |
1506 | mRULE_STRING(); | 1551 | mT__45(); |
1507 | 1552 | ||
1508 | } | 1553 | } |
1509 | break; | 1554 | break; |
1510 | case 35 : | 1555 | case 35 : |
1511 | // InternalProblem.g:1:220: RULE_QUOTED_ID | 1556 | // InternalProblem.g:1:214: T__46 |
1512 | { | 1557 | { |
1513 | mRULE_QUOTED_ID(); | 1558 | mT__46(); |
1514 | 1559 | ||
1515 | } | 1560 | } |
1516 | break; | 1561 | break; |
1517 | case 36 : | 1562 | case 36 : |
1518 | // InternalProblem.g:1:235: RULE_SL_COMMENT | 1563 | // InternalProblem.g:1:220: T__47 |
1519 | { | 1564 | { |
1520 | mRULE_SL_COMMENT(); | 1565 | mT__47(); |
1521 | 1566 | ||
1522 | } | 1567 | } |
1523 | break; | 1568 | break; |
1524 | case 37 : | 1569 | case 37 : |
1525 | // InternalProblem.g:1:251: RULE_ID | 1570 | // InternalProblem.g:1:226: RULE_ID |
1526 | { | 1571 | { |
1527 | mRULE_ID(); | 1572 | mRULE_ID(); |
1528 | 1573 | ||
1529 | } | 1574 | } |
1530 | break; | 1575 | break; |
1531 | case 38 : | 1576 | case 38 : |
1532 | // InternalProblem.g:1:259: RULE_INT | 1577 | // InternalProblem.g:1:234: RULE_STRING |
1533 | { | 1578 | { |
1534 | mRULE_INT(); | 1579 | mRULE_STRING(); |
1535 | 1580 | ||
1536 | } | 1581 | } |
1537 | break; | 1582 | break; |
1538 | case 39 : | 1583 | case 39 : |
1539 | // InternalProblem.g:1:268: RULE_ML_COMMENT | 1584 | // InternalProblem.g:1:246: RULE_QUOTED_ID |
1540 | { | 1585 | { |
1541 | mRULE_ML_COMMENT(); | 1586 | mRULE_QUOTED_ID(); |
1542 | 1587 | ||
1543 | } | 1588 | } |
1544 | break; | 1589 | break; |
1545 | case 40 : | 1590 | case 40 : |
1546 | // InternalProblem.g:1:284: RULE_WS | 1591 | // InternalProblem.g:1:261: RULE_SL_COMMENT |
1547 | { | 1592 | { |
1548 | mRULE_WS(); | 1593 | mRULE_SL_COMMENT(); |
1549 | 1594 | ||
1550 | } | 1595 | } |
1551 | break; | 1596 | break; |
1552 | case 41 : | 1597 | case 41 : |
1553 | // InternalProblem.g:1:292: RULE_ANY_OTHER | 1598 | // InternalProblem.g:1:277: RULE_INT |
1599 | { | ||
1600 | mRULE_INT(); | ||
1601 | |||
1602 | } | ||
1603 | break; | ||
1604 | case 42 : | ||
1605 | // InternalProblem.g:1:286: RULE_ML_COMMENT | ||
1606 | { | ||
1607 | mRULE_ML_COMMENT(); | ||
1608 | |||
1609 | } | ||
1610 | break; | ||
1611 | case 43 : | ||
1612 | // InternalProblem.g:1:302: RULE_WS | ||
1613 | { | ||
1614 | mRULE_WS(); | ||
1615 | |||
1616 | } | ||
1617 | break; | ||
1618 | case 44 : | ||
1619 | // InternalProblem.g:1:310: RULE_ANY_OTHER | ||
1554 | { | 1620 | { |
1555 | mRULE_ANY_OTHER(); | 1621 | mRULE_ANY_OTHER(); |
1556 | 1622 | ||
@@ -1562,74 +1628,75 @@ public class InternalProblemLexer extends Lexer { | |||
1562 | } | 1628 | } |
1563 | 1629 | ||
1564 | 1630 | ||
1565 | protected DFA12 dfa12 = new DFA12(this); | 1631 | protected DFA11 dfa11 = new DFA11(this); |
1566 | static final String DFA12_eotS = | 1632 | static final String DFA11_eotS = |
1567 | "\1\uffff\1\44\1\46\3\44\4\uffff\1\44\2\uffff\1\44\2\uffff\1\71\1\uffff\1\74\1\44\2\uffff\3\44\1\uffff\2\42\1\uffff\2\42\4\uffff\1\44\3\uffff\6\44\4\uffff\1\44\2\uffff\1\44\10\uffff\1\44\2\uffff\3\44\7\uffff\17\44\1\147\4\44\1\154\4\44\1\161\3\44\1\uffff\1\44\1\166\2\44\1\uffff\1\171\2\44\1\174\1\uffff\1\175\3\44\1\uffff\2\44\1\uffff\1\u0083\1\44\2\uffff\1\44\1\u0086\2\44\1\u0089\1\uffff\1\44\1\u008b\1\uffff\1\u008c\1\u008d\1\uffff\1\u008e\4\uffff"; | 1633 | "\1\uffff\1\45\1\47\2\45\1\56\4\uffff\1\45\2\uffff\1\45\2\uffff\1\73\1\uffff\1\76\1\45\2\uffff\2\45\1\104\1\uffff\1\45\2\uffff\2\43\1\uffff\1\43\3\uffff\1\45\3\uffff\6\45\5\uffff\1\45\2\uffff\1\45\10\uffff\1\45\2\uffff\2\45\2\uffff\1\45\7\uffff\17\45\1\153\4\45\1\160\4\45\1\165\3\45\1\uffff\1\45\1\172\2\45\1\uffff\1\175\2\45\1\u0080\1\uffff\1\u0081\3\45\1\uffff\2\45\1\uffff\1\u0087\1\45\2\uffff\1\45\1\u008a\2\45\1\u008d\1\uffff\1\45\1\u008f\1\uffff\1\u0090\1\u0091\1\uffff\1\u0092\4\uffff"; |
1568 | static final String DFA12_eofS = | 1634 | static final String DFA11_eofS = |
1569 | "\u008f\uffff"; | 1635 | "\u0093\uffff"; |
1570 | static final String DFA12_minS = | 1636 | static final String DFA11_minS = |
1571 | "\1\0\1\162\1\56\1\142\1\154\1\156\4\uffff\1\145\2\uffff\1\160\2\uffff\1\55\1\uffff\1\75\1\143\2\uffff\1\162\1\141\1\156\1\uffff\2\0\1\uffff\1\52\1\101\4\uffff\1\145\3\uffff\1\163\1\141\1\156\1\164\1\165\1\162\4\uffff\1\146\2\uffff\1\160\10\uffff\1\157\2\uffff\1\165\1\154\1\153\7\uffff\1\142\1\144\1\164\1\163\1\164\1\145\1\155\1\157\1\145\1\157\1\160\1\145\1\163\1\156\1\154\1\60\1\162\1\163\1\141\1\156\1\60\2\162\1\163\1\145\1\60\1\145\1\157\1\145\1\uffff\1\141\1\60\1\151\1\144\1\uffff\1\60\1\163\1\151\1\60\1\uffff\1\60\1\167\1\155\1\143\1\uffff\1\156\1\163\1\uffff\1\60\1\164\2\uffff\1\156\1\60\1\164\1\163\1\60\1\uffff\1\145\1\60\1\uffff\2\60\1\uffff\1\60\4\uffff"; | 1637 | "\1\0\1\162\1\56\1\142\1\154\1\60\4\uffff\1\145\2\uffff\1\160\2\uffff\1\55\1\uffff\1\75\1\143\2\uffff\1\162\1\141\1\60\1\uffff\1\156\2\uffff\2\0\1\uffff\1\52\3\uffff\1\145\3\uffff\1\163\1\141\1\156\1\164\1\165\1\162\5\uffff\1\146\2\uffff\1\160\10\uffff\1\157\2\uffff\1\165\1\154\2\uffff\1\153\7\uffff\1\142\1\144\1\164\1\163\1\164\1\145\1\155\1\157\1\145\1\157\1\160\1\145\1\163\1\156\1\154\1\60\1\162\1\163\1\141\1\156\1\60\2\162\1\163\1\145\1\60\1\145\1\157\1\145\1\uffff\1\141\1\60\1\151\1\144\1\uffff\1\60\1\163\1\151\1\60\1\uffff\1\60\1\167\1\155\1\143\1\uffff\1\156\1\163\1\uffff\1\60\1\164\2\uffff\1\156\1\60\1\164\1\163\1\60\1\uffff\1\145\1\60\1\uffff\2\60\1\uffff\1\60\4\uffff"; |
1572 | static final String DFA12_maxS = | 1638 | static final String DFA11_maxS = |
1573 | "\1\uffff\1\162\1\56\1\142\1\157\1\170\4\uffff\1\145\2\uffff\1\160\2\uffff\1\72\1\uffff\1\75\1\143\2\uffff\1\162\1\141\1\156\1\uffff\2\uffff\1\uffff\1\57\1\172\4\uffff\1\157\3\uffff\1\163\1\141\1\156\1\164\1\165\1\162\4\uffff\1\146\2\uffff\1\160\10\uffff\1\157\2\uffff\1\165\1\154\1\153\7\uffff\1\142\1\144\1\164\1\163\1\164\1\145\1\155\1\157\1\145\1\157\1\160\1\145\1\163\1\156\1\154\1\172\1\162\1\163\1\141\1\156\1\172\2\162\1\163\1\145\1\172\1\145\1\157\1\145\1\uffff\1\141\1\172\1\151\1\144\1\uffff\1\172\1\163\1\151\1\172\1\uffff\1\172\1\167\1\155\1\143\1\uffff\1\156\1\163\1\uffff\1\172\1\164\2\uffff\1\156\1\172\1\164\1\163\1\172\1\uffff\1\145\1\172\1\uffff\2\172\1\uffff\1\172\4\uffff"; | 1639 | "\1\uffff\1\162\1\56\1\142\1\157\1\172\4\uffff\1\145\2\uffff\1\160\2\uffff\1\72\1\uffff\1\75\1\143\2\uffff\1\162\1\141\1\172\1\uffff\1\156\2\uffff\2\uffff\1\uffff\1\57\3\uffff\1\157\3\uffff\1\163\1\141\1\156\1\164\1\165\1\162\5\uffff\1\146\2\uffff\1\160\10\uffff\1\157\2\uffff\1\165\1\154\2\uffff\1\153\7\uffff\1\142\1\144\1\164\1\163\1\164\1\145\1\155\1\157\1\145\1\157\1\160\1\145\1\163\1\156\1\154\1\172\1\162\1\163\1\141\1\156\1\172\2\162\1\163\1\145\1\172\1\145\1\157\1\145\1\uffff\1\141\1\172\1\151\1\144\1\uffff\1\172\1\163\1\151\1\172\1\uffff\1\172\1\167\1\155\1\143\1\uffff\1\156\1\163\1\uffff\1\172\1\164\2\uffff\1\156\1\172\1\164\1\163\1\172\1\uffff\1\145\1\172\1\uffff\2\172\1\uffff\1\172\4\uffff"; |
1574 | static final String DFA12_acceptS = | 1640 | static final String DFA11_acceptS = |
1575 | "\6\uffff\1\6\1\7\1\10\1\11\1\uffff\1\15\1\16\1\uffff\1\22\1\23\1\uffff\1\25\2\uffff\1\32\1\34\3\uffff\1\41\2\uffff\1\44\2\uffff\1\45\1\46\1\50\1\51\1\uffff\1\45\1\33\1\2\6\uffff\1\6\1\7\1\10\1\11\1\uffff\1\15\1\16\1\uffff\1\22\1\23\1\24\1\35\1\27\1\25\1\31\1\26\1\uffff\1\32\1\34\3\uffff\1\41\1\42\1\43\1\44\1\47\1\46\1\50\35\uffff\1\21\4\uffff\1\12\4\uffff\1\36\4\uffff\1\4\2\uffff\1\20\2\uffff\1\30\1\37\5\uffff\1\14\2\uffff\1\1\2\uffff\1\5\1\uffff\1\40\1\3\1\13\1\17"; | 1641 | "\6\uffff\1\6\1\7\1\10\1\11\1\uffff\1\15\1\16\1\uffff\1\22\1\23\1\uffff\1\25\2\uffff\1\32\1\34\3\uffff\1\42\1\uffff\1\44\1\45\2\uffff\1\50\1\uffff\1\51\1\53\1\54\1\uffff\1\45\1\33\1\2\6\uffff\1\40\1\6\1\7\1\10\1\11\1\uffff\1\15\1\16\1\uffff\1\22\1\23\1\24\1\35\1\27\1\25\1\31\1\26\1\uffff\1\32\1\34\2\uffff\1\41\1\42\1\uffff\1\44\1\46\1\47\1\50\1\52\1\51\1\53\35\uffff\1\21\4\uffff\1\12\4\uffff\1\36\4\uffff\1\4\2\uffff\1\20\2\uffff\1\30\1\37\5\uffff\1\14\2\uffff\1\1\2\uffff\1\5\1\uffff\1\43\1\3\1\13\1\17"; |
1576 | static final String DFA12_specialS = | 1642 | static final String DFA11_specialS = |
1577 | "\1\0\31\uffff\1\2\1\1\163\uffff}>"; | 1643 | "\1\1\34\uffff\1\2\1\0\164\uffff}>"; |
1578 | static final String[] DFA12_transitionS = { | 1644 | static final String[] DFA11_transitionS = { |
1579 | "\11\42\2\41\2\42\1\41\22\42\1\41\1\21\1\32\2\42\1\34\1\42\1\33\1\16\1\17\1\25\1\22\1\6\1\42\1\2\1\35\12\40\1\20\1\10\1\42\1\24\1\42\1\31\1\42\32\37\1\13\1\42\1\14\1\36\1\37\1\42\1\3\1\37\1\4\1\37\1\5\1\27\10\37\1\15\1\1\1\37\1\12\1\23\1\26\1\30\5\37\1\7\1\42\1\11\uff82\42", | 1645 | "\11\43\2\42\2\43\1\42\22\43\1\42\1\21\1\35\2\43\1\37\1\43\1\36\1\16\1\17\1\25\1\22\1\6\1\31\1\2\1\40\12\41\1\20\1\10\1\43\1\24\1\43\1\33\1\43\4\34\1\30\25\34\1\13\1\43\1\14\1\43\1\34\1\43\1\3\1\34\1\4\1\34\1\5\1\27\10\34\1\15\1\1\1\34\1\12\1\23\1\26\1\32\5\34\1\7\1\43\1\11\uff82\43", |
1580 | "\1\43", | 1646 | "\1\44", |
1581 | "\1\45", | 1647 | "\1\46", |
1582 | "\1\47", | 1648 | "\1\50", |
1583 | "\1\50\2\uffff\1\51", | 1649 | "\1\51\2\uffff\1\52", |
1584 | "\1\53\3\uffff\1\54\5\uffff\1\52", | 1650 | "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\15\45\1\54\3\45\1\55\5\45\1\53\2\45", |
1585 | "", | 1651 | "", |
1586 | "", | 1652 | "", |
1587 | "", | 1653 | "", |
1588 | "", | 1654 | "", |
1589 | "\1\61", | 1655 | "\1\63", |
1590 | "", | 1656 | "", |
1591 | "", | 1657 | "", |
1592 | "\1\64", | 1658 | "\1\66", |
1593 | "", | 1659 | "", |
1594 | "", | 1660 | "", |
1595 | "\1\67\14\uffff\1\70", | 1661 | "\1\71\14\uffff\1\72", |
1596 | "", | 1662 | "", |
1597 | "\1\73", | ||
1598 | "\1\75", | 1663 | "\1\75", |
1664 | "\1\77", | ||
1599 | "", | 1665 | "", |
1600 | "", | 1666 | "", |
1601 | "\1\100", | ||
1602 | "\1\101", | ||
1603 | "\1\102", | 1667 | "\1\102", |
1668 | "\1\103", | ||
1669 | "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", | ||
1604 | "", | 1670 | "", |
1605 | "\0\104", | 1671 | "\1\106", |
1606 | "\0\105", | ||
1607 | "", | 1672 | "", |
1608 | "\1\107\4\uffff\1\106", | ||
1609 | "\32\44\4\uffff\1\44\1\uffff\32\44", | ||
1610 | "", | 1673 | "", |
1674 | "\0\110", | ||
1675 | "\0\111", | ||
1611 | "", | 1676 | "", |
1677 | "\1\113\4\uffff\1\112", | ||
1612 | "", | 1678 | "", |
1613 | "", | 1679 | "", |
1614 | "\1\113\11\uffff\1\112", | 1680 | "", |
1681 | "\1\117\11\uffff\1\116", | ||
1615 | "", | 1682 | "", |
1616 | "", | 1683 | "", |
1617 | "", | 1684 | "", |
1618 | "\1\114", | ||
1619 | "\1\115", | ||
1620 | "\1\116", | ||
1621 | "\1\117", | ||
1622 | "\1\120", | 1685 | "\1\120", |
1623 | "\1\121", | 1686 | "\1\121", |
1687 | "\1\122", | ||
1688 | "\1\123", | ||
1689 | "\1\124", | ||
1690 | "\1\125", | ||
1624 | "", | 1691 | "", |
1625 | "", | 1692 | "", |
1626 | "", | 1693 | "", |
1627 | "", | 1694 | "", |
1628 | "\1\122", | ||
1629 | "", | 1695 | "", |
1696 | "\1\126", | ||
1630 | "", | 1697 | "", |
1631 | "\1\123", | ||
1632 | "", | 1698 | "", |
1699 | "\1\127", | ||
1633 | "", | 1700 | "", |
1634 | "", | 1701 | "", |
1635 | "", | 1702 | "", |
@@ -1637,12 +1704,15 @@ public class InternalProblemLexer extends Lexer { | |||
1637 | "", | 1704 | "", |
1638 | "", | 1705 | "", |
1639 | "", | 1706 | "", |
1640 | "\1\124", | ||
1641 | "", | 1707 | "", |
1708 | "\1\130", | ||
1642 | "", | 1709 | "", |
1643 | "\1\125", | 1710 | "", |
1644 | "\1\126", | 1711 | "\1\131", |
1645 | "\1\127", | 1712 | "\1\132", |
1713 | "", | ||
1714 | "", | ||
1715 | "\1\133", | ||
1646 | "", | 1716 | "", |
1647 | "", | 1717 | "", |
1648 | "", | 1718 | "", |
@@ -1650,10 +1720,6 @@ public class InternalProblemLexer extends Lexer { | |||
1650 | "", | 1720 | "", |
1651 | "", | 1721 | "", |
1652 | "", | 1722 | "", |
1653 | "\1\130", | ||
1654 | "\1\131", | ||
1655 | "\1\132", | ||
1656 | "\1\133", | ||
1657 | "\1\134", | 1723 | "\1\134", |
1658 | "\1\135", | 1724 | "\1\135", |
1659 | "\1\136", | 1725 | "\1\136", |
@@ -1665,195 +1731,201 @@ public class InternalProblemLexer extends Lexer { | |||
1665 | "\1\144", | 1731 | "\1\144", |
1666 | "\1\145", | 1732 | "\1\145", |
1667 | "\1\146", | 1733 | "\1\146", |
1668 | "\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44", | 1734 | "\1\147", |
1669 | "\1\150", | 1735 | "\1\150", |
1670 | "\1\151", | 1736 | "\1\151", |
1671 | "\1\152", | 1737 | "\1\152", |
1672 | "\1\153", | 1738 | "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", |
1673 | "\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44", | 1739 | "\1\154", |
1674 | "\1\155", | 1740 | "\1\155", |
1675 | "\1\156", | 1741 | "\1\156", |
1676 | "\1\157", | 1742 | "\1\157", |
1677 | "\1\160", | 1743 | "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", |
1678 | "\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44", | 1744 | "\1\161", |
1679 | "\1\162", | 1745 | "\1\162", |
1680 | "\1\163", | 1746 | "\1\163", |
1681 | "\1\164", | 1747 | "\1\164", |
1682 | "", | 1748 | "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", |
1683 | "\1\165", | 1749 | "\1\166", |
1684 | "\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44", | ||
1685 | "\1\167", | 1750 | "\1\167", |
1686 | "\1\170", | 1751 | "\1\170", |
1687 | "", | 1752 | "", |
1688 | "\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44", | 1753 | "\1\171", |
1689 | "\1\172", | 1754 | "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", |
1690 | "\1\173", | 1755 | "\1\173", |
1691 | "\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44", | 1756 | "\1\174", |
1692 | "", | 1757 | "", |
1693 | "\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44", | 1758 | "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", |
1694 | "\1\176", | 1759 | "\1\176", |
1695 | "\1\177", | 1760 | "\1\177", |
1696 | "\1\u0080", | 1761 | "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", |
1697 | "", | 1762 | "", |
1698 | "\1\u0081", | 1763 | "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", |
1699 | "\1\u0082", | 1764 | "\1\u0082", |
1700 | "", | 1765 | "\1\u0083", |
1701 | "\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44", | ||
1702 | "\1\u0084", | 1766 | "\1\u0084", |
1703 | "", | 1767 | "", |
1704 | "", | ||
1705 | "\1\u0085", | 1768 | "\1\u0085", |
1706 | "\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44", | 1769 | "\1\u0086", |
1707 | "\1\u0087", | 1770 | "", |
1771 | "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", | ||
1708 | "\1\u0088", | 1772 | "\1\u0088", |
1709 | "\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44", | ||
1710 | "", | 1773 | "", |
1711 | "\1\u008a", | ||
1712 | "\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44", | ||
1713 | "", | 1774 | "", |
1714 | "\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44", | 1775 | "\1\u0089", |
1715 | "\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44", | 1776 | "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", |
1777 | "\1\u008b", | ||
1778 | "\1\u008c", | ||
1779 | "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", | ||
1780 | "", | ||
1781 | "\1\u008e", | ||
1782 | "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", | ||
1716 | "", | 1783 | "", |
1717 | "\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44", | 1784 | "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", |
1785 | "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", | ||
1786 | "", | ||
1787 | "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", | ||
1718 | "", | 1788 | "", |
1719 | "", | 1789 | "", |
1720 | "", | 1790 | "", |
1721 | "" | 1791 | "" |
1722 | }; | 1792 | }; |
1723 | 1793 | ||
1724 | static final short[] DFA12_eot = DFA.unpackEncodedString(DFA12_eotS); | 1794 | static final short[] DFA11_eot = DFA.unpackEncodedString(DFA11_eotS); |
1725 | static final short[] DFA12_eof = DFA.unpackEncodedString(DFA12_eofS); | 1795 | static final short[] DFA11_eof = DFA.unpackEncodedString(DFA11_eofS); |
1726 | static final char[] DFA12_min = DFA.unpackEncodedStringToUnsignedChars(DFA12_minS); | 1796 | static final char[] DFA11_min = DFA.unpackEncodedStringToUnsignedChars(DFA11_minS); |
1727 | static final char[] DFA12_max = DFA.unpackEncodedStringToUnsignedChars(DFA12_maxS); | 1797 | static final char[] DFA11_max = DFA.unpackEncodedStringToUnsignedChars(DFA11_maxS); |
1728 | static final short[] DFA12_accept = DFA.unpackEncodedString(DFA12_acceptS); | 1798 | static final short[] DFA11_accept = DFA.unpackEncodedString(DFA11_acceptS); |
1729 | static final short[] DFA12_special = DFA.unpackEncodedString(DFA12_specialS); | 1799 | static final short[] DFA11_special = DFA.unpackEncodedString(DFA11_specialS); |
1730 | static final short[][] DFA12_transition; | 1800 | static final short[][] DFA11_transition; |
1731 | 1801 | ||
1732 | static { | 1802 | static { |
1733 | int numStates = DFA12_transitionS.length; | 1803 | int numStates = DFA11_transitionS.length; |
1734 | DFA12_transition = new short[numStates][]; | 1804 | DFA11_transition = new short[numStates][]; |
1735 | for (int i=0; i<numStates; i++) { | 1805 | for (int i=0; i<numStates; i++) { |
1736 | DFA12_transition[i] = DFA.unpackEncodedString(DFA12_transitionS[i]); | 1806 | DFA11_transition[i] = DFA.unpackEncodedString(DFA11_transitionS[i]); |
1737 | } | 1807 | } |
1738 | } | 1808 | } |
1739 | 1809 | ||
1740 | class DFA12 extends DFA { | 1810 | class DFA11 extends DFA { |
1741 | 1811 | ||
1742 | public DFA12(BaseRecognizer recognizer) { | 1812 | public DFA11(BaseRecognizer recognizer) { |
1743 | this.recognizer = recognizer; | 1813 | this.recognizer = recognizer; |
1744 | this.decisionNumber = 12; | 1814 | this.decisionNumber = 11; |
1745 | this.eot = DFA12_eot; | 1815 | this.eot = DFA11_eot; |
1746 | this.eof = DFA12_eof; | 1816 | this.eof = DFA11_eof; |
1747 | this.min = DFA12_min; | 1817 | this.min = DFA11_min; |
1748 | this.max = DFA12_max; | 1818 | this.max = DFA11_max; |
1749 | this.accept = DFA12_accept; | 1819 | this.accept = DFA11_accept; |
1750 | this.special = DFA12_special; | 1820 | this.special = DFA11_special; |
1751 | this.transition = DFA12_transition; | 1821 | this.transition = DFA11_transition; |
1752 | } | 1822 | } |
1753 | public String getDescription() { | 1823 | public String getDescription() { |
1754 | return "1:1: Tokens : ( T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | RULE_STRING | RULE_QUOTED_ID | RULE_SL_COMMENT | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER );"; | 1824 | return "1:1: Tokens : ( T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | RULE_ID | RULE_STRING | RULE_QUOTED_ID | RULE_SL_COMMENT | RULE_INT | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER );"; |
1755 | } | 1825 | } |
1756 | public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { | 1826 | public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
1757 | IntStream input = _input; | 1827 | IntStream input = _input; |
1758 | int _s = s; | 1828 | int _s = s; |
1759 | switch ( s ) { | 1829 | switch ( s ) { |
1760 | case 0 : | 1830 | case 0 : |
1761 | int LA12_0 = input.LA(1); | 1831 | int LA11_30 = input.LA(1); |
1762 | 1832 | ||
1763 | s = -1; | 1833 | s = -1; |
1764 | if ( (LA12_0=='p') ) {s = 1;} | 1834 | if ( ((LA11_30>='\u0000' && LA11_30<='\uFFFF')) ) {s = 73;} |
1765 | 1835 | ||
1766 | else if ( (LA12_0=='.') ) {s = 2;} | 1836 | else s = 35; |
1767 | 1837 | ||
1768 | else if ( (LA12_0=='a') ) {s = 3;} | 1838 | if ( s>=0 ) return s; |
1839 | break; | ||
1840 | case 1 : | ||
1841 | int LA11_0 = input.LA(1); | ||
1769 | 1842 | ||
1770 | else if ( (LA12_0=='c') ) {s = 4;} | 1843 | s = -1; |
1844 | if ( (LA11_0=='p') ) {s = 1;} | ||
1771 | 1845 | ||
1772 | else if ( (LA12_0=='e') ) {s = 5;} | 1846 | else if ( (LA11_0=='.') ) {s = 2;} |
1773 | 1847 | ||
1774 | else if ( (LA12_0==',') ) {s = 6;} | 1848 | else if ( (LA11_0=='a') ) {s = 3;} |
1775 | 1849 | ||
1776 | else if ( (LA12_0=='{') ) {s = 7;} | 1850 | else if ( (LA11_0=='c') ) {s = 4;} |
1777 | 1851 | ||
1778 | else if ( (LA12_0==';') ) {s = 8;} | 1852 | else if ( (LA11_0=='e') ) {s = 5;} |
1779 | 1853 | ||
1780 | else if ( (LA12_0=='}') ) {s = 9;} | 1854 | else if ( (LA11_0==',') ) {s = 6;} |
1781 | 1855 | ||
1782 | else if ( (LA12_0=='r') ) {s = 10;} | 1856 | else if ( (LA11_0=='{') ) {s = 7;} |
1783 | 1857 | ||
1784 | else if ( (LA12_0=='[') ) {s = 11;} | 1858 | else if ( (LA11_0==';') ) {s = 8;} |
1785 | 1859 | ||
1786 | else if ( (LA12_0==']') ) {s = 12;} | 1860 | else if ( (LA11_0=='}') ) {s = 9;} |
1787 | 1861 | ||
1788 | else if ( (LA12_0=='o') ) {s = 13;} | 1862 | else if ( (LA11_0=='r') ) {s = 10;} |
1789 | 1863 | ||
1790 | else if ( (LA12_0=='(') ) {s = 14;} | 1864 | else if ( (LA11_0=='[') ) {s = 11;} |
1791 | 1865 | ||
1792 | else if ( (LA12_0==')') ) {s = 15;} | 1866 | else if ( (LA11_0==']') ) {s = 12;} |
1793 | 1867 | ||
1794 | else if ( (LA12_0==':') ) {s = 16;} | 1868 | else if ( (LA11_0=='o') ) {s = 13;} |
1795 | 1869 | ||
1796 | else if ( (LA12_0=='!') ) {s = 17;} | 1870 | else if ( (LA11_0=='(') ) {s = 14;} |
1797 | 1871 | ||
1798 | else if ( (LA12_0=='+') ) {s = 18;} | 1872 | else if ( (LA11_0==')') ) {s = 15;} |
1799 | 1873 | ||
1800 | else if ( (LA12_0=='s') ) {s = 19;} | 1874 | else if ( (LA11_0==':') ) {s = 16;} |
1801 | 1875 | ||
1802 | else if ( (LA12_0=='=') ) {s = 20;} | 1876 | else if ( (LA11_0=='!') ) {s = 17;} |
1803 | 1877 | ||
1804 | else if ( (LA12_0=='*') ) {s = 21;} | 1878 | else if ( (LA11_0=='+') ) {s = 18;} |
1805 | 1879 | ||
1806 | else if ( (LA12_0=='t') ) {s = 22;} | 1880 | else if ( (LA11_0=='s') ) {s = 19;} |
1807 | 1881 | ||
1808 | else if ( (LA12_0=='f') ) {s = 23;} | 1882 | else if ( (LA11_0=='=') ) {s = 20;} |
1809 | 1883 | ||
1810 | else if ( (LA12_0=='u') ) {s = 24;} | 1884 | else if ( (LA11_0=='*') ) {s = 21;} |
1811 | 1885 | ||
1812 | else if ( (LA12_0=='?') ) {s = 25;} | 1886 | else if ( (LA11_0=='t') ) {s = 22;} |
1813 | 1887 | ||
1814 | else if ( (LA12_0=='\"') ) {s = 26;} | 1888 | else if ( (LA11_0=='f') ) {s = 23;} |
1815 | 1889 | ||
1816 | else if ( (LA12_0=='\'') ) {s = 27;} | 1890 | else if ( (LA11_0=='E') ) {s = 24;} |
1817 | 1891 | ||
1818 | else if ( (LA12_0=='%') ) {s = 28;} | 1892 | else if ( (LA11_0=='-') ) {s = 25;} |
1819 | 1893 | ||
1820 | else if ( (LA12_0=='/') ) {s = 29;} | 1894 | else if ( (LA11_0=='u') ) {s = 26;} |
1821 | 1895 | ||
1822 | else if ( (LA12_0=='^') ) {s = 30;} | 1896 | else if ( (LA11_0=='?') ) {s = 27;} |
1823 | 1897 | ||
1824 | else if ( ((LA12_0>='A' && LA12_0<='Z')||LA12_0=='_'||LA12_0=='b'||LA12_0=='d'||(LA12_0>='g' && LA12_0<='n')||LA12_0=='q'||(LA12_0>='v' && LA12_0<='z')) ) {s = 31;} | 1898 | else if ( ((LA11_0>='A' && LA11_0<='D')||(LA11_0>='F' && LA11_0<='Z')||LA11_0=='_'||LA11_0=='b'||LA11_0=='d'||(LA11_0>='g' && LA11_0<='n')||LA11_0=='q'||(LA11_0>='v' && LA11_0<='z')) ) {s = 28;} |
1825 | 1899 | ||
1826 | else if ( ((LA12_0>='0' && LA12_0<='9')) ) {s = 32;} | 1900 | else if ( (LA11_0=='\"') ) {s = 29;} |
1827 | 1901 | ||
1828 | else if ( ((LA12_0>='\t' && LA12_0<='\n')||LA12_0=='\r'||LA12_0==' ') ) {s = 33;} | 1902 | else if ( (LA11_0=='\'') ) {s = 30;} |
1829 | 1903 | ||
1830 | else if ( ((LA12_0>='\u0000' && LA12_0<='\b')||(LA12_0>='\u000B' && LA12_0<='\f')||(LA12_0>='\u000E' && LA12_0<='\u001F')||(LA12_0>='#' && LA12_0<='$')||LA12_0=='&'||LA12_0=='-'||LA12_0=='<'||LA12_0=='>'||LA12_0=='@'||LA12_0=='\\'||LA12_0=='`'||LA12_0=='|'||(LA12_0>='~' && LA12_0<='\uFFFF')) ) {s = 34;} | 1904 | else if ( (LA11_0=='%') ) {s = 31;} |
1831 | 1905 | ||
1832 | if ( s>=0 ) return s; | 1906 | else if ( (LA11_0=='/') ) {s = 32;} |
1833 | break; | ||
1834 | case 1 : | ||
1835 | int LA12_27 = input.LA(1); | ||
1836 | 1907 | ||
1837 | s = -1; | 1908 | else if ( ((LA11_0>='0' && LA11_0<='9')) ) {s = 33;} |
1838 | if ( ((LA12_27>='\u0000' && LA12_27<='\uFFFF')) ) {s = 69;} | 1909 | |
1910 | else if ( ((LA11_0>='\t' && LA11_0<='\n')||LA11_0=='\r'||LA11_0==' ') ) {s = 34;} | ||
1839 | 1911 | ||
1840 | else s = 34; | 1912 | else if ( ((LA11_0>='\u0000' && LA11_0<='\b')||(LA11_0>='\u000B' && LA11_0<='\f')||(LA11_0>='\u000E' && LA11_0<='\u001F')||(LA11_0>='#' && LA11_0<='$')||LA11_0=='&'||LA11_0=='<'||LA11_0=='>'||LA11_0=='@'||LA11_0=='\\'||LA11_0=='^'||LA11_0=='`'||LA11_0=='|'||(LA11_0>='~' && LA11_0<='\uFFFF')) ) {s = 35;} |
1841 | 1913 | ||
1842 | if ( s>=0 ) return s; | 1914 | if ( s>=0 ) return s; |
1843 | break; | 1915 | break; |
1844 | case 2 : | 1916 | case 2 : |
1845 | int LA12_26 = input.LA(1); | 1917 | int LA11_29 = input.LA(1); |
1846 | 1918 | ||
1847 | s = -1; | 1919 | s = -1; |
1848 | if ( ((LA12_26>='\u0000' && LA12_26<='\uFFFF')) ) {s = 68;} | 1920 | if ( ((LA11_29>='\u0000' && LA11_29<='\uFFFF')) ) {s = 72;} |
1849 | 1921 | ||
1850 | else s = 34; | 1922 | else s = 35; |
1851 | 1923 | ||
1852 | if ( s>=0 ) return s; | 1924 | if ( s>=0 ) return s; |
1853 | break; | 1925 | break; |
1854 | } | 1926 | } |
1855 | NoViableAltException nvae = | 1927 | NoViableAltException nvae = |
1856 | new NoViableAltException(getDescription(), 12, _s, input); | 1928 | new NoViableAltException(getDescription(), 11, _s, input); |
1857 | error(nvae); | 1929 | error(nvae); |
1858 | throw nvae; | 1930 | throw nvae; |
1859 | } | 1931 | } |
diff --git a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblemParser.java b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblemParser.java index fa8643aa..cd8f706a 100644 --- a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblemParser.java +++ b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblemParser.java | |||
@@ -22,7 +22,7 @@ import java.util.ArrayList; | |||
22 | @SuppressWarnings("all") | 22 | @SuppressWarnings("all") |
23 | public class InternalProblemParser extends AbstractInternalAntlrParser { | 23 | public class InternalProblemParser extends AbstractInternalAntlrParser { |
24 | public static final String[] tokenNames = new String[] { | 24 | public static final String[] tokenNames = new String[] { |
25 | "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_ID", "RULE_INT", "RULE_QUOTED_ID", "RULE_STRING", "RULE_SL_COMMENT", "RULE_ML_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'problem'", "'.'", "'abstract'", "'class'", "'extends'", "','", "'{'", "';'", "'}'", "'enum'", "'contains'", "'refers'", "'['", "']'", "'opposite'", "'error'", "'pred'", "'('", "')'", "':-'", "'!'", "'+'", "':'", "'scope'", "'+='", "'='", "'..'", "'*'", "'::'", "'true'", "'false'", "'unknown'", "'?'" | 25 | "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_STRING", "RULE_ID", "RULE_INT", "RULE_QUOTED_ID", "RULE_SL_COMMENT", "RULE_ML_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'problem'", "'.'", "'abstract'", "'class'", "'extends'", "','", "'{'", "';'", "'}'", "'enum'", "'contains'", "'refers'", "'['", "']'", "'opposite'", "'error'", "'pred'", "'('", "')'", "':-'", "'!'", "'+'", "':'", "'scope'", "'+='", "'='", "'..'", "'*'", "'::'", "'true'", "'false'", "'e'", "'E'", "'-'", "'unknown'", "'?'" |
26 | }; | 26 | }; |
27 | public static final int T__19=19; | 27 | public static final int T__19=19; |
28 | public static final int T__15=15; | 28 | public static final int T__15=15; |
@@ -32,12 +32,12 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
32 | public static final int T__12=12; | 32 | public static final int T__12=12; |
33 | public static final int T__13=13; | 33 | public static final int T__13=13; |
34 | public static final int T__14=14; | 34 | public static final int T__14=14; |
35 | public static final int RULE_ID=4; | 35 | public static final int RULE_ID=5; |
36 | public static final int RULE_QUOTED_ID=6; | 36 | public static final int RULE_QUOTED_ID=7; |
37 | public static final int T__26=26; | 37 | public static final int T__26=26; |
38 | public static final int T__27=27; | 38 | public static final int T__27=27; |
39 | public static final int T__28=28; | 39 | public static final int T__28=28; |
40 | public static final int RULE_INT=5; | 40 | public static final int RULE_INT=6; |
41 | public static final int T__29=29; | 41 | public static final int T__29=29; |
42 | public static final int T__22=22; | 42 | public static final int T__22=22; |
43 | public static final int RULE_ML_COMMENT=9; | 43 | public static final int RULE_ML_COMMENT=9; |
@@ -46,7 +46,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
46 | public static final int T__25=25; | 46 | public static final int T__25=25; |
47 | public static final int T__20=20; | 47 | public static final int T__20=20; |
48 | public static final int T__21=21; | 48 | public static final int T__21=21; |
49 | public static final int RULE_STRING=7; | 49 | public static final int RULE_STRING=4; |
50 | public static final int RULE_SL_COMMENT=8; | 50 | public static final int RULE_SL_COMMENT=8; |
51 | public static final int T__37=37; | 51 | public static final int T__37=37; |
52 | public static final int T__38=38; | 52 | public static final int T__38=38; |
@@ -62,6 +62,9 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
62 | public static final int RULE_WS=10; | 62 | public static final int RULE_WS=10; |
63 | public static final int RULE_ANY_OTHER=11; | 63 | public static final int RULE_ANY_OTHER=11; |
64 | public static final int T__44=44; | 64 | public static final int T__44=44; |
65 | public static final int T__45=45; | ||
66 | public static final int T__46=46; | ||
67 | public static final int T__47=47; | ||
65 | public static final int T__40=40; | 68 | public static final int T__40=40; |
66 | public static final int T__41=41; | 69 | public static final int T__41=41; |
67 | public static final int T__42=42; | 70 | public static final int T__42=42; |
@@ -226,7 +229,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
226 | int alt2=2; | 229 | int alt2=2; |
227 | int LA2_0 = input.LA(1); | 230 | int LA2_0 = input.LA(1); |
228 | 231 | ||
229 | if ( (LA2_0==RULE_ID||LA2_0==RULE_QUOTED_ID||(LA2_0>=14 && LA2_0<=15)||LA2_0==21||(LA2_0>=27 && LA2_0<=28)||LA2_0==32||LA2_0==35||(LA2_0>=41 && LA2_0<=42)||LA2_0==44) ) { | 232 | if ( (LA2_0==RULE_ID||LA2_0==RULE_QUOTED_ID||(LA2_0>=14 && LA2_0<=15)||LA2_0==21||(LA2_0>=27 && LA2_0<=28)||LA2_0==32||LA2_0==35||(LA2_0>=41 && LA2_0<=44)||LA2_0==47) ) { |
230 | alt2=1; | 233 | alt2=1; |
231 | } | 234 | } |
232 | 235 | ||
@@ -328,7 +331,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
328 | 331 | ||
329 | 332 | ||
330 | // $ANTLR start "ruleStatement" | 333 | // $ANTLR start "ruleStatement" |
331 | // InternalProblem.g:139:1: ruleStatement returns [EObject current=null] : (this_ClassDeclaration_0= ruleClassDeclaration | this_EnumDeclaration_1= ruleEnumDeclaration | this_PredicateDefinition_2= rulePredicateDefinition | this_Assertion_3= ruleAssertion | this_ScopeDeclaration_4= ruleScopeDeclaration ) ; | 334 | // InternalProblem.g:139:1: ruleStatement returns [EObject current=null] : (this_ClassDeclaration_0= ruleClassDeclaration | this_EnumDeclaration_1= ruleEnumDeclaration | this_PredicateDefinition_2= rulePredicateDefinition | this_Assertion_3= ruleAssertion | this_NodeValueAssertion_4= ruleNodeValueAssertion | this_ScopeDeclaration_5= ruleScopeDeclaration ) ; |
332 | public final EObject ruleStatement() throws RecognitionException { | 335 | public final EObject ruleStatement() throws RecognitionException { |
333 | EObject current = null; | 336 | EObject current = null; |
334 | 337 | ||
@@ -340,58 +343,21 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
340 | 343 | ||
341 | EObject this_Assertion_3 = null; | 344 | EObject this_Assertion_3 = null; |
342 | 345 | ||
343 | EObject this_ScopeDeclaration_4 = null; | 346 | EObject this_NodeValueAssertion_4 = null; |
347 | |||
348 | EObject this_ScopeDeclaration_5 = null; | ||
344 | 349 | ||
345 | 350 | ||
346 | 351 | ||
347 | enterRule(); | 352 | enterRule(); |
348 | 353 | ||
349 | try { | 354 | try { |
350 | // InternalProblem.g:145:2: ( (this_ClassDeclaration_0= ruleClassDeclaration | this_EnumDeclaration_1= ruleEnumDeclaration | this_PredicateDefinition_2= rulePredicateDefinition | this_Assertion_3= ruleAssertion | this_ScopeDeclaration_4= ruleScopeDeclaration ) ) | 355 | // InternalProblem.g:145:2: ( (this_ClassDeclaration_0= ruleClassDeclaration | this_EnumDeclaration_1= ruleEnumDeclaration | this_PredicateDefinition_2= rulePredicateDefinition | this_Assertion_3= ruleAssertion | this_NodeValueAssertion_4= ruleNodeValueAssertion | this_ScopeDeclaration_5= ruleScopeDeclaration ) ) |
351 | // InternalProblem.g:146:2: (this_ClassDeclaration_0= ruleClassDeclaration | this_EnumDeclaration_1= ruleEnumDeclaration | this_PredicateDefinition_2= rulePredicateDefinition | this_Assertion_3= ruleAssertion | this_ScopeDeclaration_4= ruleScopeDeclaration ) | 356 | // InternalProblem.g:146:2: (this_ClassDeclaration_0= ruleClassDeclaration | this_EnumDeclaration_1= ruleEnumDeclaration | this_PredicateDefinition_2= rulePredicateDefinition | this_Assertion_3= ruleAssertion | this_NodeValueAssertion_4= ruleNodeValueAssertion | this_ScopeDeclaration_5= ruleScopeDeclaration ) |
352 | { | 357 | { |
353 | // InternalProblem.g:146:2: (this_ClassDeclaration_0= ruleClassDeclaration | this_EnumDeclaration_1= ruleEnumDeclaration | this_PredicateDefinition_2= rulePredicateDefinition | this_Assertion_3= ruleAssertion | this_ScopeDeclaration_4= ruleScopeDeclaration ) | 358 | // InternalProblem.g:146:2: (this_ClassDeclaration_0= ruleClassDeclaration | this_EnumDeclaration_1= ruleEnumDeclaration | this_PredicateDefinition_2= rulePredicateDefinition | this_Assertion_3= ruleAssertion | this_NodeValueAssertion_4= ruleNodeValueAssertion | this_ScopeDeclaration_5= ruleScopeDeclaration ) |
354 | int alt3=5; | 359 | int alt3=6; |
355 | switch ( input.LA(1) ) { | 360 | alt3 = dfa3.predict(input); |
356 | case 14: | ||
357 | case 15: | ||
358 | { | ||
359 | alt3=1; | ||
360 | } | ||
361 | break; | ||
362 | case 21: | ||
363 | { | ||
364 | alt3=2; | ||
365 | } | ||
366 | break; | ||
367 | case 27: | ||
368 | case 28: | ||
369 | { | ||
370 | alt3=3; | ||
371 | } | ||
372 | break; | ||
373 | case RULE_ID: | ||
374 | case RULE_QUOTED_ID: | ||
375 | case 32: | ||
376 | case 41: | ||
377 | case 42: | ||
378 | case 44: | ||
379 | { | ||
380 | alt3=4; | ||
381 | } | ||
382 | break; | ||
383 | case 35: | ||
384 | { | ||
385 | alt3=5; | ||
386 | } | ||
387 | break; | ||
388 | default: | ||
389 | NoViableAltException nvae = | ||
390 | new NoViableAltException("", 3, 0, input); | ||
391 | |||
392 | throw nvae; | ||
393 | } | ||
394 | |||
395 | switch (alt3) { | 361 | switch (alt3) { |
396 | case 1 : | 362 | case 1 : |
397 | // InternalProblem.g:147:3: this_ClassDeclaration_0= ruleClassDeclaration | 363 | // InternalProblem.g:147:3: this_ClassDeclaration_0= ruleClassDeclaration |
@@ -466,18 +432,36 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
466 | } | 432 | } |
467 | break; | 433 | break; |
468 | case 5 : | 434 | case 5 : |
469 | // InternalProblem.g:183:3: this_ScopeDeclaration_4= ruleScopeDeclaration | 435 | // InternalProblem.g:183:3: this_NodeValueAssertion_4= ruleNodeValueAssertion |
470 | { | 436 | { |
471 | 437 | ||
472 | newCompositeNode(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_4()); | 438 | newCompositeNode(grammarAccess.getStatementAccess().getNodeValueAssertionParserRuleCall_4()); |
473 | 439 | ||
474 | pushFollow(FOLLOW_2); | 440 | pushFollow(FOLLOW_2); |
475 | this_ScopeDeclaration_4=ruleScopeDeclaration(); | 441 | this_NodeValueAssertion_4=ruleNodeValueAssertion(); |
476 | 442 | ||
477 | state._fsp--; | 443 | state._fsp--; |
478 | 444 | ||
479 | 445 | ||
480 | current = this_ScopeDeclaration_4; | 446 | current = this_NodeValueAssertion_4; |
447 | afterParserOrEnumRuleCall(); | ||
448 | |||
449 | |||
450 | } | ||
451 | break; | ||
452 | case 6 : | ||
453 | // InternalProblem.g:192:3: this_ScopeDeclaration_5= ruleScopeDeclaration | ||
454 | { | ||
455 | |||
456 | newCompositeNode(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_5()); | ||
457 | |||
458 | pushFollow(FOLLOW_2); | ||
459 | this_ScopeDeclaration_5=ruleScopeDeclaration(); | ||
460 | |||
461 | state._fsp--; | ||
462 | |||
463 | |||
464 | current = this_ScopeDeclaration_5; | ||
481 | afterParserOrEnumRuleCall(); | 465 | afterParserOrEnumRuleCall(); |
482 | 466 | ||
483 | 467 | ||
@@ -506,7 +490,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
506 | 490 | ||
507 | 491 | ||
508 | // $ANTLR start "entryRuleClassDeclaration" | 492 | // $ANTLR start "entryRuleClassDeclaration" |
509 | // InternalProblem.g:195:1: entryRuleClassDeclaration returns [EObject current=null] : iv_ruleClassDeclaration= ruleClassDeclaration EOF ; | 493 | // InternalProblem.g:204:1: entryRuleClassDeclaration returns [EObject current=null] : iv_ruleClassDeclaration= ruleClassDeclaration EOF ; |
510 | public final EObject entryRuleClassDeclaration() throws RecognitionException { | 494 | public final EObject entryRuleClassDeclaration() throws RecognitionException { |
511 | EObject current = null; | 495 | EObject current = null; |
512 | 496 | ||
@@ -514,8 +498,8 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
514 | 498 | ||
515 | 499 | ||
516 | try { | 500 | try { |
517 | // InternalProblem.g:195:57: (iv_ruleClassDeclaration= ruleClassDeclaration EOF ) | 501 | // InternalProblem.g:204:57: (iv_ruleClassDeclaration= ruleClassDeclaration EOF ) |
518 | // InternalProblem.g:196:2: iv_ruleClassDeclaration= ruleClassDeclaration EOF | 502 | // InternalProblem.g:205:2: iv_ruleClassDeclaration= ruleClassDeclaration EOF |
519 | { | 503 | { |
520 | newCompositeNode(grammarAccess.getClassDeclarationRule()); | 504 | newCompositeNode(grammarAccess.getClassDeclarationRule()); |
521 | pushFollow(FOLLOW_1); | 505 | pushFollow(FOLLOW_1); |
@@ -542,7 +526,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
542 | 526 | ||
543 | 527 | ||
544 | // $ANTLR start "ruleClassDeclaration" | 528 | // $ANTLR start "ruleClassDeclaration" |
545 | // InternalProblem.g:202:1: ruleClassDeclaration returns [EObject current=null] : ( ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_name_2_0= ruleIdentifier ) ) (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? ( (otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' ) | otherlv_11= '.' ) ) ; | 529 | // InternalProblem.g:211:1: ruleClassDeclaration returns [EObject current=null] : ( ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_name_2_0= ruleIdentifier ) ) (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? ( (otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' ) | otherlv_11= '.' ) ) ; |
546 | public final EObject ruleClassDeclaration() throws RecognitionException { | 530 | public final EObject ruleClassDeclaration() throws RecognitionException { |
547 | EObject current = null; | 531 | EObject current = null; |
548 | 532 | ||
@@ -563,13 +547,13 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
563 | enterRule(); | 547 | enterRule(); |
564 | 548 | ||
565 | try { | 549 | try { |
566 | // InternalProblem.g:208:2: ( ( ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_name_2_0= ruleIdentifier ) ) (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? ( (otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' ) | otherlv_11= '.' ) ) ) | 550 | // InternalProblem.g:217:2: ( ( ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_name_2_0= ruleIdentifier ) ) (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? ( (otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' ) | otherlv_11= '.' ) ) ) |
567 | // InternalProblem.g:209:2: ( ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_name_2_0= ruleIdentifier ) ) (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? ( (otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' ) | otherlv_11= '.' ) ) | 551 | // InternalProblem.g:218:2: ( ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_name_2_0= ruleIdentifier ) ) (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? ( (otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' ) | otherlv_11= '.' ) ) |
568 | { | 552 | { |
569 | // InternalProblem.g:209:2: ( ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_name_2_0= ruleIdentifier ) ) (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? ( (otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' ) | otherlv_11= '.' ) ) | 553 | // InternalProblem.g:218:2: ( ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_name_2_0= ruleIdentifier ) ) (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? ( (otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' ) | otherlv_11= '.' ) ) |
570 | // InternalProblem.g:210:3: ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_name_2_0= ruleIdentifier ) ) (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? ( (otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' ) | otherlv_11= '.' ) | 554 | // InternalProblem.g:219:3: ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_name_2_0= ruleIdentifier ) ) (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? ( (otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' ) | otherlv_11= '.' ) |
571 | { | 555 | { |
572 | // InternalProblem.g:210:3: ( (lv_abstract_0_0= 'abstract' ) )? | 556 | // InternalProblem.g:219:3: ( (lv_abstract_0_0= 'abstract' ) )? |
573 | int alt4=2; | 557 | int alt4=2; |
574 | int LA4_0 = input.LA(1); | 558 | int LA4_0 = input.LA(1); |
575 | 559 | ||
@@ -578,10 +562,10 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
578 | } | 562 | } |
579 | switch (alt4) { | 563 | switch (alt4) { |
580 | case 1 : | 564 | case 1 : |
581 | // InternalProblem.g:211:4: (lv_abstract_0_0= 'abstract' ) | 565 | // InternalProblem.g:220:4: (lv_abstract_0_0= 'abstract' ) |
582 | { | 566 | { |
583 | // InternalProblem.g:211:4: (lv_abstract_0_0= 'abstract' ) | 567 | // InternalProblem.g:220:4: (lv_abstract_0_0= 'abstract' ) |
584 | // InternalProblem.g:212:5: lv_abstract_0_0= 'abstract' | 568 | // InternalProblem.g:221:5: lv_abstract_0_0= 'abstract' |
585 | { | 569 | { |
586 | lv_abstract_0_0=(Token)match(input,14,FOLLOW_6); | 570 | lv_abstract_0_0=(Token)match(input,14,FOLLOW_6); |
587 | 571 | ||
@@ -606,11 +590,11 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
606 | 590 | ||
607 | newLeafNode(otherlv_1, grammarAccess.getClassDeclarationAccess().getClassKeyword_1()); | 591 | newLeafNode(otherlv_1, grammarAccess.getClassDeclarationAccess().getClassKeyword_1()); |
608 | 592 | ||
609 | // InternalProblem.g:228:3: ( (lv_name_2_0= ruleIdentifier ) ) | 593 | // InternalProblem.g:237:3: ( (lv_name_2_0= ruleIdentifier ) ) |
610 | // InternalProblem.g:229:4: (lv_name_2_0= ruleIdentifier ) | 594 | // InternalProblem.g:238:4: (lv_name_2_0= ruleIdentifier ) |
611 | { | 595 | { |
612 | // InternalProblem.g:229:4: (lv_name_2_0= ruleIdentifier ) | 596 | // InternalProblem.g:238:4: (lv_name_2_0= ruleIdentifier ) |
613 | // InternalProblem.g:230:5: lv_name_2_0= ruleIdentifier | 597 | // InternalProblem.g:239:5: lv_name_2_0= ruleIdentifier |
614 | { | 598 | { |
615 | 599 | ||
616 | newCompositeNode(grammarAccess.getClassDeclarationAccess().getNameIdentifierParserRuleCall_2_0()); | 600 | newCompositeNode(grammarAccess.getClassDeclarationAccess().getNameIdentifierParserRuleCall_2_0()); |
@@ -637,7 +621,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
637 | 621 | ||
638 | } | 622 | } |
639 | 623 | ||
640 | // InternalProblem.g:247:3: (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? | 624 | // InternalProblem.g:256:3: (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? |
641 | int alt6=2; | 625 | int alt6=2; |
642 | int LA6_0 = input.LA(1); | 626 | int LA6_0 = input.LA(1); |
643 | 627 | ||
@@ -646,17 +630,17 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
646 | } | 630 | } |
647 | switch (alt6) { | 631 | switch (alt6) { |
648 | case 1 : | 632 | case 1 : |
649 | // InternalProblem.g:248:4: otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* | 633 | // InternalProblem.g:257:4: otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* |
650 | { | 634 | { |
651 | otherlv_3=(Token)match(input,16,FOLLOW_8); | 635 | otherlv_3=(Token)match(input,16,FOLLOW_8); |
652 | 636 | ||
653 | newLeafNode(otherlv_3, grammarAccess.getClassDeclarationAccess().getExtendsKeyword_3_0()); | 637 | newLeafNode(otherlv_3, grammarAccess.getClassDeclarationAccess().getExtendsKeyword_3_0()); |
654 | 638 | ||
655 | // InternalProblem.g:252:4: ( ( ruleQualifiedName ) ) | 639 | // InternalProblem.g:261:4: ( ( ruleQualifiedName ) ) |
656 | // InternalProblem.g:253:5: ( ruleQualifiedName ) | 640 | // InternalProblem.g:262:5: ( ruleQualifiedName ) |
657 | { | 641 | { |
658 | // InternalProblem.g:253:5: ( ruleQualifiedName ) | 642 | // InternalProblem.g:262:5: ( ruleQualifiedName ) |
659 | // InternalProblem.g:254:6: ruleQualifiedName | 643 | // InternalProblem.g:263:6: ruleQualifiedName |
660 | { | 644 | { |
661 | 645 | ||
662 | if (current==null) { | 646 | if (current==null) { |
@@ -680,7 +664,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
680 | 664 | ||
681 | } | 665 | } |
682 | 666 | ||
683 | // InternalProblem.g:268:4: (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* | 667 | // InternalProblem.g:277:4: (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* |
684 | loop5: | 668 | loop5: |
685 | do { | 669 | do { |
686 | int alt5=2; | 670 | int alt5=2; |
@@ -693,17 +677,17 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
693 | 677 | ||
694 | switch (alt5) { | 678 | switch (alt5) { |
695 | case 1 : | 679 | case 1 : |
696 | // InternalProblem.g:269:5: otherlv_5= ',' ( ( ruleQualifiedName ) ) | 680 | // InternalProblem.g:278:5: otherlv_5= ',' ( ( ruleQualifiedName ) ) |
697 | { | 681 | { |
698 | otherlv_5=(Token)match(input,17,FOLLOW_8); | 682 | otherlv_5=(Token)match(input,17,FOLLOW_8); |
699 | 683 | ||
700 | newLeafNode(otherlv_5, grammarAccess.getClassDeclarationAccess().getCommaKeyword_3_2_0()); | 684 | newLeafNode(otherlv_5, grammarAccess.getClassDeclarationAccess().getCommaKeyword_3_2_0()); |
701 | 685 | ||
702 | // InternalProblem.g:273:5: ( ( ruleQualifiedName ) ) | 686 | // InternalProblem.g:282:5: ( ( ruleQualifiedName ) ) |
703 | // InternalProblem.g:274:6: ( ruleQualifiedName ) | 687 | // InternalProblem.g:283:6: ( ruleQualifiedName ) |
704 | { | 688 | { |
705 | // InternalProblem.g:274:6: ( ruleQualifiedName ) | 689 | // InternalProblem.g:283:6: ( ruleQualifiedName ) |
706 | // InternalProblem.g:275:7: ruleQualifiedName | 690 | // InternalProblem.g:284:7: ruleQualifiedName |
707 | { | 691 | { |
708 | 692 | ||
709 | if (current==null) { | 693 | if (current==null) { |
@@ -742,7 +726,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
742 | 726 | ||
743 | } | 727 | } |
744 | 728 | ||
745 | // InternalProblem.g:291:3: ( (otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' ) | otherlv_11= '.' ) | 729 | // InternalProblem.g:300:3: ( (otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' ) | otherlv_11= '.' ) |
746 | int alt9=2; | 730 | int alt9=2; |
747 | int LA9_0 = input.LA(1); | 731 | int LA9_0 = input.LA(1); |
748 | 732 | ||
@@ -760,35 +744,35 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
760 | } | 744 | } |
761 | switch (alt9) { | 745 | switch (alt9) { |
762 | case 1 : | 746 | case 1 : |
763 | // InternalProblem.g:292:4: (otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' ) | 747 | // InternalProblem.g:301:4: (otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' ) |
764 | { | 748 | { |
765 | // InternalProblem.g:292:4: (otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' ) | 749 | // InternalProblem.g:301:4: (otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' ) |
766 | // InternalProblem.g:293:5: otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' | 750 | // InternalProblem.g:302:5: otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' |
767 | { | 751 | { |
768 | otherlv_7=(Token)match(input,18,FOLLOW_10); | 752 | otherlv_7=(Token)match(input,18,FOLLOW_10); |
769 | 753 | ||
770 | newLeafNode(otherlv_7, grammarAccess.getClassDeclarationAccess().getLeftCurlyBracketKeyword_4_0_0()); | 754 | newLeafNode(otherlv_7, grammarAccess.getClassDeclarationAccess().getLeftCurlyBracketKeyword_4_0_0()); |
771 | 755 | ||
772 | // InternalProblem.g:297:5: ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* | 756 | // InternalProblem.g:306:5: ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* |
773 | loop8: | 757 | loop8: |
774 | do { | 758 | do { |
775 | int alt8=2; | 759 | int alt8=2; |
776 | int LA8_0 = input.LA(1); | 760 | int LA8_0 = input.LA(1); |
777 | 761 | ||
778 | if ( (LA8_0==RULE_ID||LA8_0==RULE_QUOTED_ID||(LA8_0>=22 && LA8_0<=23)||(LA8_0>=41 && LA8_0<=42)) ) { | 762 | if ( (LA8_0==RULE_ID||LA8_0==RULE_QUOTED_ID||(LA8_0>=22 && LA8_0<=23)||(LA8_0>=41 && LA8_0<=44)) ) { |
779 | alt8=1; | 763 | alt8=1; |
780 | } | 764 | } |
781 | 765 | ||
782 | 766 | ||
783 | switch (alt8) { | 767 | switch (alt8) { |
784 | case 1 : | 768 | case 1 : |
785 | // InternalProblem.g:298:6: ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? | 769 | // InternalProblem.g:307:6: ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? |
786 | { | 770 | { |
787 | // InternalProblem.g:298:6: ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) | 771 | // InternalProblem.g:307:6: ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) |
788 | // InternalProblem.g:299:7: (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) | 772 | // InternalProblem.g:308:7: (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) |
789 | { | 773 | { |
790 | // InternalProblem.g:299:7: (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) | 774 | // InternalProblem.g:308:7: (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) |
791 | // InternalProblem.g:300:8: lv_referenceDeclarations_8_0= ruleReferenceDeclaration | 775 | // InternalProblem.g:309:8: lv_referenceDeclarations_8_0= ruleReferenceDeclaration |
792 | { | 776 | { |
793 | 777 | ||
794 | newCompositeNode(grammarAccess.getClassDeclarationAccess().getReferenceDeclarationsReferenceDeclarationParserRuleCall_4_0_1_0_0()); | 778 | newCompositeNode(grammarAccess.getClassDeclarationAccess().getReferenceDeclarationsReferenceDeclarationParserRuleCall_4_0_1_0_0()); |
@@ -815,7 +799,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
815 | 799 | ||
816 | } | 800 | } |
817 | 801 | ||
818 | // InternalProblem.g:317:6: (otherlv_9= ';' )? | 802 | // InternalProblem.g:326:6: (otherlv_9= ';' )? |
819 | int alt7=2; | 803 | int alt7=2; |
820 | int LA7_0 = input.LA(1); | 804 | int LA7_0 = input.LA(1); |
821 | 805 | ||
@@ -824,7 +808,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
824 | } | 808 | } |
825 | switch (alt7) { | 809 | switch (alt7) { |
826 | case 1 : | 810 | case 1 : |
827 | // InternalProblem.g:318:7: otherlv_9= ';' | 811 | // InternalProblem.g:327:7: otherlv_9= ';' |
828 | { | 812 | { |
829 | otherlv_9=(Token)match(input,19,FOLLOW_10); | 813 | otherlv_9=(Token)match(input,19,FOLLOW_10); |
830 | 814 | ||
@@ -856,7 +840,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
856 | } | 840 | } |
857 | break; | 841 | break; |
858 | case 2 : | 842 | case 2 : |
859 | // InternalProblem.g:330:4: otherlv_11= '.' | 843 | // InternalProblem.g:339:4: otherlv_11= '.' |
860 | { | 844 | { |
861 | otherlv_11=(Token)match(input,13,FOLLOW_2); | 845 | otherlv_11=(Token)match(input,13,FOLLOW_2); |
862 | 846 | ||
@@ -891,7 +875,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
891 | 875 | ||
892 | 876 | ||
893 | // $ANTLR start "entryRuleEnumDeclaration" | 877 | // $ANTLR start "entryRuleEnumDeclaration" |
894 | // InternalProblem.g:339:1: entryRuleEnumDeclaration returns [EObject current=null] : iv_ruleEnumDeclaration= ruleEnumDeclaration EOF ; | 878 | // InternalProblem.g:348:1: entryRuleEnumDeclaration returns [EObject current=null] : iv_ruleEnumDeclaration= ruleEnumDeclaration EOF ; |
895 | public final EObject entryRuleEnumDeclaration() throws RecognitionException { | 879 | public final EObject entryRuleEnumDeclaration() throws RecognitionException { |
896 | EObject current = null; | 880 | EObject current = null; |
897 | 881 | ||
@@ -899,8 +883,8 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
899 | 883 | ||
900 | 884 | ||
901 | try { | 885 | try { |
902 | // InternalProblem.g:339:56: (iv_ruleEnumDeclaration= ruleEnumDeclaration EOF ) | 886 | // InternalProblem.g:348:56: (iv_ruleEnumDeclaration= ruleEnumDeclaration EOF ) |
903 | // InternalProblem.g:340:2: iv_ruleEnumDeclaration= ruleEnumDeclaration EOF | 887 | // InternalProblem.g:349:2: iv_ruleEnumDeclaration= ruleEnumDeclaration EOF |
904 | { | 888 | { |
905 | newCompositeNode(grammarAccess.getEnumDeclarationRule()); | 889 | newCompositeNode(grammarAccess.getEnumDeclarationRule()); |
906 | pushFollow(FOLLOW_1); | 890 | pushFollow(FOLLOW_1); |
@@ -927,7 +911,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
927 | 911 | ||
928 | 912 | ||
929 | // $ANTLR start "ruleEnumDeclaration" | 913 | // $ANTLR start "ruleEnumDeclaration" |
930 | // InternalProblem.g:346:1: ruleEnumDeclaration returns [EObject current=null] : (otherlv_0= 'enum' ( (lv_name_1_0= ruleIdentifier ) ) ( (otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' ) | otherlv_9= '.' ) ) ; | 914 | // InternalProblem.g:355:1: ruleEnumDeclaration returns [EObject current=null] : (otherlv_0= 'enum' ( (lv_name_1_0= ruleIdentifier ) ) ( (otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' ) | otherlv_9= '.' ) ) ; |
931 | public final EObject ruleEnumDeclaration() throws RecognitionException { | 915 | public final EObject ruleEnumDeclaration() throws RecognitionException { |
932 | EObject current = null; | 916 | EObject current = null; |
933 | 917 | ||
@@ -949,21 +933,21 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
949 | enterRule(); | 933 | enterRule(); |
950 | 934 | ||
951 | try { | 935 | try { |
952 | // InternalProblem.g:352:2: ( (otherlv_0= 'enum' ( (lv_name_1_0= ruleIdentifier ) ) ( (otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' ) | otherlv_9= '.' ) ) ) | 936 | // InternalProblem.g:361:2: ( (otherlv_0= 'enum' ( (lv_name_1_0= ruleIdentifier ) ) ( (otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' ) | otherlv_9= '.' ) ) ) |
953 | // InternalProblem.g:353:2: (otherlv_0= 'enum' ( (lv_name_1_0= ruleIdentifier ) ) ( (otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' ) | otherlv_9= '.' ) ) | 937 | // InternalProblem.g:362:2: (otherlv_0= 'enum' ( (lv_name_1_0= ruleIdentifier ) ) ( (otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' ) | otherlv_9= '.' ) ) |
954 | { | 938 | { |
955 | // InternalProblem.g:353:2: (otherlv_0= 'enum' ( (lv_name_1_0= ruleIdentifier ) ) ( (otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' ) | otherlv_9= '.' ) ) | 939 | // InternalProblem.g:362:2: (otherlv_0= 'enum' ( (lv_name_1_0= ruleIdentifier ) ) ( (otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' ) | otherlv_9= '.' ) ) |
956 | // InternalProblem.g:354:3: otherlv_0= 'enum' ( (lv_name_1_0= ruleIdentifier ) ) ( (otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' ) | otherlv_9= '.' ) | 940 | // InternalProblem.g:363:3: otherlv_0= 'enum' ( (lv_name_1_0= ruleIdentifier ) ) ( (otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' ) | otherlv_9= '.' ) |
957 | { | 941 | { |
958 | otherlv_0=(Token)match(input,21,FOLLOW_3); | 942 | otherlv_0=(Token)match(input,21,FOLLOW_3); |
959 | 943 | ||
960 | newLeafNode(otherlv_0, grammarAccess.getEnumDeclarationAccess().getEnumKeyword_0()); | 944 | newLeafNode(otherlv_0, grammarAccess.getEnumDeclarationAccess().getEnumKeyword_0()); |
961 | 945 | ||
962 | // InternalProblem.g:358:3: ( (lv_name_1_0= ruleIdentifier ) ) | 946 | // InternalProblem.g:367:3: ( (lv_name_1_0= ruleIdentifier ) ) |
963 | // InternalProblem.g:359:4: (lv_name_1_0= ruleIdentifier ) | 947 | // InternalProblem.g:368:4: (lv_name_1_0= ruleIdentifier ) |
964 | { | 948 | { |
965 | // InternalProblem.g:359:4: (lv_name_1_0= ruleIdentifier ) | 949 | // InternalProblem.g:368:4: (lv_name_1_0= ruleIdentifier ) |
966 | // InternalProblem.g:360:5: lv_name_1_0= ruleIdentifier | 950 | // InternalProblem.g:369:5: lv_name_1_0= ruleIdentifier |
967 | { | 951 | { |
968 | 952 | ||
969 | newCompositeNode(grammarAccess.getEnumDeclarationAccess().getNameIdentifierParserRuleCall_1_0()); | 953 | newCompositeNode(grammarAccess.getEnumDeclarationAccess().getNameIdentifierParserRuleCall_1_0()); |
@@ -990,7 +974,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
990 | 974 | ||
991 | } | 975 | } |
992 | 976 | ||
993 | // InternalProblem.g:377:3: ( (otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' ) | otherlv_9= '.' ) | 977 | // InternalProblem.g:386:3: ( (otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' ) | otherlv_9= '.' ) |
994 | int alt13=2; | 978 | int alt13=2; |
995 | int LA13_0 = input.LA(1); | 979 | int LA13_0 = input.LA(1); |
996 | 980 | ||
@@ -1008,31 +992,31 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1008 | } | 992 | } |
1009 | switch (alt13) { | 993 | switch (alt13) { |
1010 | case 1 : | 994 | case 1 : |
1011 | // InternalProblem.g:378:4: (otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' ) | 995 | // InternalProblem.g:387:4: (otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' ) |
1012 | { | 996 | { |
1013 | // InternalProblem.g:378:4: (otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' ) | 997 | // InternalProblem.g:387:4: (otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' ) |
1014 | // InternalProblem.g:379:5: otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' | 998 | // InternalProblem.g:388:5: otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' |
1015 | { | 999 | { |
1016 | otherlv_2=(Token)match(input,18,FOLLOW_13); | 1000 | otherlv_2=(Token)match(input,18,FOLLOW_13); |
1017 | 1001 | ||
1018 | newLeafNode(otherlv_2, grammarAccess.getEnumDeclarationAccess().getLeftCurlyBracketKeyword_2_0_0()); | 1002 | newLeafNode(otherlv_2, grammarAccess.getEnumDeclarationAccess().getLeftCurlyBracketKeyword_2_0_0()); |
1019 | 1003 | ||
1020 | // InternalProblem.g:383:5: ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? | 1004 | // InternalProblem.g:392:5: ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? |
1021 | int alt12=2; | 1005 | int alt12=2; |
1022 | int LA12_0 = input.LA(1); | 1006 | int LA12_0 = input.LA(1); |
1023 | 1007 | ||
1024 | if ( (LA12_0==RULE_ID||LA12_0==RULE_QUOTED_ID||(LA12_0>=41 && LA12_0<=42)) ) { | 1008 | if ( (LA12_0==RULE_ID||LA12_0==RULE_QUOTED_ID||(LA12_0>=41 && LA12_0<=44)) ) { |
1025 | alt12=1; | 1009 | alt12=1; |
1026 | } | 1010 | } |
1027 | switch (alt12) { | 1011 | switch (alt12) { |
1028 | case 1 : | 1012 | case 1 : |
1029 | // InternalProblem.g:384:6: ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? | 1013 | // InternalProblem.g:393:6: ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? |
1030 | { | 1014 | { |
1031 | // InternalProblem.g:384:6: ( (lv_literals_3_0= ruleEnumLiteral ) ) | 1015 | // InternalProblem.g:393:6: ( (lv_literals_3_0= ruleEnumLiteral ) ) |
1032 | // InternalProblem.g:385:7: (lv_literals_3_0= ruleEnumLiteral ) | 1016 | // InternalProblem.g:394:7: (lv_literals_3_0= ruleEnumLiteral ) |
1033 | { | 1017 | { |
1034 | // InternalProblem.g:385:7: (lv_literals_3_0= ruleEnumLiteral ) | 1018 | // InternalProblem.g:394:7: (lv_literals_3_0= ruleEnumLiteral ) |
1035 | // InternalProblem.g:386:8: lv_literals_3_0= ruleEnumLiteral | 1019 | // InternalProblem.g:395:8: lv_literals_3_0= ruleEnumLiteral |
1036 | { | 1020 | { |
1037 | 1021 | ||
1038 | newCompositeNode(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_0_0()); | 1022 | newCompositeNode(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_0_0()); |
@@ -1059,7 +1043,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1059 | 1043 | ||
1060 | } | 1044 | } |
1061 | 1045 | ||
1062 | // InternalProblem.g:403:6: (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* | 1046 | // InternalProblem.g:412:6: (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* |
1063 | loop10: | 1047 | loop10: |
1064 | do { | 1048 | do { |
1065 | int alt10=2; | 1049 | int alt10=2; |
@@ -1068,7 +1052,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1068 | if ( (LA10_0==17) ) { | 1052 | if ( (LA10_0==17) ) { |
1069 | int LA10_1 = input.LA(2); | 1053 | int LA10_1 = input.LA(2); |
1070 | 1054 | ||
1071 | if ( (LA10_1==RULE_ID||LA10_1==RULE_QUOTED_ID||(LA10_1>=41 && LA10_1<=42)) ) { | 1055 | if ( (LA10_1==RULE_ID||LA10_1==RULE_QUOTED_ID||(LA10_1>=41 && LA10_1<=44)) ) { |
1072 | alt10=1; | 1056 | alt10=1; |
1073 | } | 1057 | } |
1074 | 1058 | ||
@@ -1078,17 +1062,17 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1078 | 1062 | ||
1079 | switch (alt10) { | 1063 | switch (alt10) { |
1080 | case 1 : | 1064 | case 1 : |
1081 | // InternalProblem.g:404:7: otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) | 1065 | // InternalProblem.g:413:7: otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) |
1082 | { | 1066 | { |
1083 | otherlv_4=(Token)match(input,17,FOLLOW_8); | 1067 | otherlv_4=(Token)match(input,17,FOLLOW_8); |
1084 | 1068 | ||
1085 | newLeafNode(otherlv_4, grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_1_0()); | 1069 | newLeafNode(otherlv_4, grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_1_0()); |
1086 | 1070 | ||
1087 | // InternalProblem.g:408:7: ( (lv_literals_5_0= ruleEnumLiteral ) ) | 1071 | // InternalProblem.g:417:7: ( (lv_literals_5_0= ruleEnumLiteral ) ) |
1088 | // InternalProblem.g:409:8: (lv_literals_5_0= ruleEnumLiteral ) | 1072 | // InternalProblem.g:418:8: (lv_literals_5_0= ruleEnumLiteral ) |
1089 | { | 1073 | { |
1090 | // InternalProblem.g:409:8: (lv_literals_5_0= ruleEnumLiteral ) | 1074 | // InternalProblem.g:418:8: (lv_literals_5_0= ruleEnumLiteral ) |
1091 | // InternalProblem.g:410:9: lv_literals_5_0= ruleEnumLiteral | 1075 | // InternalProblem.g:419:9: lv_literals_5_0= ruleEnumLiteral |
1092 | { | 1076 | { |
1093 | 1077 | ||
1094 | newCompositeNode(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_1_1_0()); | 1078 | newCompositeNode(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_1_1_0()); |
@@ -1124,7 +1108,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1124 | } | 1108 | } |
1125 | } while (true); | 1109 | } while (true); |
1126 | 1110 | ||
1127 | // InternalProblem.g:428:6: (otherlv_6= ',' | otherlv_7= ';' )? | 1111 | // InternalProblem.g:437:6: (otherlv_6= ',' | otherlv_7= ';' )? |
1128 | int alt11=3; | 1112 | int alt11=3; |
1129 | int LA11_0 = input.LA(1); | 1113 | int LA11_0 = input.LA(1); |
1130 | 1114 | ||
@@ -1136,7 +1120,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1136 | } | 1120 | } |
1137 | switch (alt11) { | 1121 | switch (alt11) { |
1138 | case 1 : | 1122 | case 1 : |
1139 | // InternalProblem.g:429:7: otherlv_6= ',' | 1123 | // InternalProblem.g:438:7: otherlv_6= ',' |
1140 | { | 1124 | { |
1141 | otherlv_6=(Token)match(input,17,FOLLOW_15); | 1125 | otherlv_6=(Token)match(input,17,FOLLOW_15); |
1142 | 1126 | ||
@@ -1146,7 +1130,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1146 | } | 1130 | } |
1147 | break; | 1131 | break; |
1148 | case 2 : | 1132 | case 2 : |
1149 | // InternalProblem.g:434:7: otherlv_7= ';' | 1133 | // InternalProblem.g:443:7: otherlv_7= ';' |
1150 | { | 1134 | { |
1151 | otherlv_7=(Token)match(input,19,FOLLOW_15); | 1135 | otherlv_7=(Token)match(input,19,FOLLOW_15); |
1152 | 1136 | ||
@@ -1175,7 +1159,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1175 | } | 1159 | } |
1176 | break; | 1160 | break; |
1177 | case 2 : | 1161 | case 2 : |
1178 | // InternalProblem.g:446:4: otherlv_9= '.' | 1162 | // InternalProblem.g:455:4: otherlv_9= '.' |
1179 | { | 1163 | { |
1180 | otherlv_9=(Token)match(input,13,FOLLOW_2); | 1164 | otherlv_9=(Token)match(input,13,FOLLOW_2); |
1181 | 1165 | ||
@@ -1210,7 +1194,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1210 | 1194 | ||
1211 | 1195 | ||
1212 | // $ANTLR start "entryRuleEnumLiteral" | 1196 | // $ANTLR start "entryRuleEnumLiteral" |
1213 | // InternalProblem.g:455:1: entryRuleEnumLiteral returns [EObject current=null] : iv_ruleEnumLiteral= ruleEnumLiteral EOF ; | 1197 | // InternalProblem.g:464:1: entryRuleEnumLiteral returns [EObject current=null] : iv_ruleEnumLiteral= ruleEnumLiteral EOF ; |
1214 | public final EObject entryRuleEnumLiteral() throws RecognitionException { | 1198 | public final EObject entryRuleEnumLiteral() throws RecognitionException { |
1215 | EObject current = null; | 1199 | EObject current = null; |
1216 | 1200 | ||
@@ -1218,8 +1202,8 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1218 | 1202 | ||
1219 | 1203 | ||
1220 | try { | 1204 | try { |
1221 | // InternalProblem.g:455:52: (iv_ruleEnumLiteral= ruleEnumLiteral EOF ) | 1205 | // InternalProblem.g:464:52: (iv_ruleEnumLiteral= ruleEnumLiteral EOF ) |
1222 | // InternalProblem.g:456:2: iv_ruleEnumLiteral= ruleEnumLiteral EOF | 1206 | // InternalProblem.g:465:2: iv_ruleEnumLiteral= ruleEnumLiteral EOF |
1223 | { | 1207 | { |
1224 | newCompositeNode(grammarAccess.getEnumLiteralRule()); | 1208 | newCompositeNode(grammarAccess.getEnumLiteralRule()); |
1225 | pushFollow(FOLLOW_1); | 1209 | pushFollow(FOLLOW_1); |
@@ -1246,7 +1230,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1246 | 1230 | ||
1247 | 1231 | ||
1248 | // $ANTLR start "ruleEnumLiteral" | 1232 | // $ANTLR start "ruleEnumLiteral" |
1249 | // InternalProblem.g:462:1: ruleEnumLiteral returns [EObject current=null] : ( (lv_name_0_0= ruleQuotedOrUnquotedId ) ) ; | 1233 | // InternalProblem.g:471:1: ruleEnumLiteral returns [EObject current=null] : ( (lv_name_0_0= ruleQuotedOrUnquotedId ) ) ; |
1250 | public final EObject ruleEnumLiteral() throws RecognitionException { | 1234 | public final EObject ruleEnumLiteral() throws RecognitionException { |
1251 | EObject current = null; | 1235 | EObject current = null; |
1252 | 1236 | ||
@@ -1257,14 +1241,14 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1257 | enterRule(); | 1241 | enterRule(); |
1258 | 1242 | ||
1259 | try { | 1243 | try { |
1260 | // InternalProblem.g:468:2: ( ( (lv_name_0_0= ruleQuotedOrUnquotedId ) ) ) | 1244 | // InternalProblem.g:477:2: ( ( (lv_name_0_0= ruleQuotedOrUnquotedId ) ) ) |
1261 | // InternalProblem.g:469:2: ( (lv_name_0_0= ruleQuotedOrUnquotedId ) ) | 1245 | // InternalProblem.g:478:2: ( (lv_name_0_0= ruleQuotedOrUnquotedId ) ) |
1262 | { | 1246 | { |
1263 | // InternalProblem.g:469:2: ( (lv_name_0_0= ruleQuotedOrUnquotedId ) ) | 1247 | // InternalProblem.g:478:2: ( (lv_name_0_0= ruleQuotedOrUnquotedId ) ) |
1264 | // InternalProblem.g:470:3: (lv_name_0_0= ruleQuotedOrUnquotedId ) | 1248 | // InternalProblem.g:479:3: (lv_name_0_0= ruleQuotedOrUnquotedId ) |
1265 | { | 1249 | { |
1266 | // InternalProblem.g:470:3: (lv_name_0_0= ruleQuotedOrUnquotedId ) | 1250 | // InternalProblem.g:479:3: (lv_name_0_0= ruleQuotedOrUnquotedId ) |
1267 | // InternalProblem.g:471:4: lv_name_0_0= ruleQuotedOrUnquotedId | 1251 | // InternalProblem.g:480:4: lv_name_0_0= ruleQuotedOrUnquotedId |
1268 | { | 1252 | { |
1269 | 1253 | ||
1270 | newCompositeNode(grammarAccess.getEnumLiteralAccess().getNameQuotedOrUnquotedIdParserRuleCall_0()); | 1254 | newCompositeNode(grammarAccess.getEnumLiteralAccess().getNameQuotedOrUnquotedIdParserRuleCall_0()); |
@@ -1311,7 +1295,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1311 | 1295 | ||
1312 | 1296 | ||
1313 | // $ANTLR start "entryRuleReferenceDeclaration" | 1297 | // $ANTLR start "entryRuleReferenceDeclaration" |
1314 | // InternalProblem.g:491:1: entryRuleReferenceDeclaration returns [EObject current=null] : iv_ruleReferenceDeclaration= ruleReferenceDeclaration EOF ; | 1298 | // InternalProblem.g:500:1: entryRuleReferenceDeclaration returns [EObject current=null] : iv_ruleReferenceDeclaration= ruleReferenceDeclaration EOF ; |
1315 | public final EObject entryRuleReferenceDeclaration() throws RecognitionException { | 1299 | public final EObject entryRuleReferenceDeclaration() throws RecognitionException { |
1316 | EObject current = null; | 1300 | EObject current = null; |
1317 | 1301 | ||
@@ -1319,8 +1303,8 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1319 | 1303 | ||
1320 | 1304 | ||
1321 | try { | 1305 | try { |
1322 | // InternalProblem.g:491:61: (iv_ruleReferenceDeclaration= ruleReferenceDeclaration EOF ) | 1306 | // InternalProblem.g:500:61: (iv_ruleReferenceDeclaration= ruleReferenceDeclaration EOF ) |
1323 | // InternalProblem.g:492:2: iv_ruleReferenceDeclaration= ruleReferenceDeclaration EOF | 1307 | // InternalProblem.g:501:2: iv_ruleReferenceDeclaration= ruleReferenceDeclaration EOF |
1324 | { | 1308 | { |
1325 | newCompositeNode(grammarAccess.getReferenceDeclarationRule()); | 1309 | newCompositeNode(grammarAccess.getReferenceDeclarationRule()); |
1326 | pushFollow(FOLLOW_1); | 1310 | pushFollow(FOLLOW_1); |
@@ -1347,7 +1331,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1347 | 1331 | ||
1348 | 1332 | ||
1349 | // $ANTLR start "ruleReferenceDeclaration" | 1333 | // $ANTLR start "ruleReferenceDeclaration" |
1350 | // InternalProblem.g:498:1: ruleReferenceDeclaration returns [EObject current=null] : ( ( ( (lv_containment_0_0= 'contains' ) ) | otherlv_1= 'refers' )? ( ( ruleQualifiedName ) ) (otherlv_3= '[' ( (lv_multiplicity_4_0= ruleMultiplicity ) ) otherlv_5= ']' )? ( (lv_name_6_0= ruleIdentifier ) ) (otherlv_7= 'opposite' ( ( ruleQualifiedName ) ) )? ) ; | 1334 | // InternalProblem.g:507:1: ruleReferenceDeclaration returns [EObject current=null] : ( ( ( (lv_containment_0_0= 'contains' ) ) | otherlv_1= 'refers' )? ( ( ruleQualifiedName ) ) (otherlv_3= '[' ( (lv_multiplicity_4_0= ruleMultiplicity ) ) otherlv_5= ']' )? ( (lv_name_6_0= ruleIdentifier ) ) (otherlv_7= 'opposite' ( ( ruleQualifiedName ) ) )? ) ; |
1351 | public final EObject ruleReferenceDeclaration() throws RecognitionException { | 1335 | public final EObject ruleReferenceDeclaration() throws RecognitionException { |
1352 | EObject current = null; | 1336 | EObject current = null; |
1353 | 1337 | ||
@@ -1365,13 +1349,13 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1365 | enterRule(); | 1349 | enterRule(); |
1366 | 1350 | ||
1367 | try { | 1351 | try { |
1368 | // InternalProblem.g:504:2: ( ( ( ( (lv_containment_0_0= 'contains' ) ) | otherlv_1= 'refers' )? ( ( ruleQualifiedName ) ) (otherlv_3= '[' ( (lv_multiplicity_4_0= ruleMultiplicity ) ) otherlv_5= ']' )? ( (lv_name_6_0= ruleIdentifier ) ) (otherlv_7= 'opposite' ( ( ruleQualifiedName ) ) )? ) ) | 1352 | // InternalProblem.g:513:2: ( ( ( ( (lv_containment_0_0= 'contains' ) ) | otherlv_1= 'refers' )? ( ( ruleQualifiedName ) ) (otherlv_3= '[' ( (lv_multiplicity_4_0= ruleMultiplicity ) ) otherlv_5= ']' )? ( (lv_name_6_0= ruleIdentifier ) ) (otherlv_7= 'opposite' ( ( ruleQualifiedName ) ) )? ) ) |
1369 | // InternalProblem.g:505:2: ( ( ( (lv_containment_0_0= 'contains' ) ) | otherlv_1= 'refers' )? ( ( ruleQualifiedName ) ) (otherlv_3= '[' ( (lv_multiplicity_4_0= ruleMultiplicity ) ) otherlv_5= ']' )? ( (lv_name_6_0= ruleIdentifier ) ) (otherlv_7= 'opposite' ( ( ruleQualifiedName ) ) )? ) | 1353 | // InternalProblem.g:514:2: ( ( ( (lv_containment_0_0= 'contains' ) ) | otherlv_1= 'refers' )? ( ( ruleQualifiedName ) ) (otherlv_3= '[' ( (lv_multiplicity_4_0= ruleMultiplicity ) ) otherlv_5= ']' )? ( (lv_name_6_0= ruleIdentifier ) ) (otherlv_7= 'opposite' ( ( ruleQualifiedName ) ) )? ) |
1370 | { | 1354 | { |
1371 | // InternalProblem.g:505:2: ( ( ( (lv_containment_0_0= 'contains' ) ) | otherlv_1= 'refers' )? ( ( ruleQualifiedName ) ) (otherlv_3= '[' ( (lv_multiplicity_4_0= ruleMultiplicity ) ) otherlv_5= ']' )? ( (lv_name_6_0= ruleIdentifier ) ) (otherlv_7= 'opposite' ( ( ruleQualifiedName ) ) )? ) | 1355 | // InternalProblem.g:514:2: ( ( ( (lv_containment_0_0= 'contains' ) ) | otherlv_1= 'refers' )? ( ( ruleQualifiedName ) ) (otherlv_3= '[' ( (lv_multiplicity_4_0= ruleMultiplicity ) ) otherlv_5= ']' )? ( (lv_name_6_0= ruleIdentifier ) ) (otherlv_7= 'opposite' ( ( ruleQualifiedName ) ) )? ) |
1372 | // InternalProblem.g:506:3: ( ( (lv_containment_0_0= 'contains' ) ) | otherlv_1= 'refers' )? ( ( ruleQualifiedName ) ) (otherlv_3= '[' ( (lv_multiplicity_4_0= ruleMultiplicity ) ) otherlv_5= ']' )? ( (lv_name_6_0= ruleIdentifier ) ) (otherlv_7= 'opposite' ( ( ruleQualifiedName ) ) )? | 1356 | // InternalProblem.g:515:3: ( ( (lv_containment_0_0= 'contains' ) ) | otherlv_1= 'refers' )? ( ( ruleQualifiedName ) ) (otherlv_3= '[' ( (lv_multiplicity_4_0= ruleMultiplicity ) ) otherlv_5= ']' )? ( (lv_name_6_0= ruleIdentifier ) ) (otherlv_7= 'opposite' ( ( ruleQualifiedName ) ) )? |
1373 | { | 1357 | { |
1374 | // InternalProblem.g:506:3: ( ( (lv_containment_0_0= 'contains' ) ) | otherlv_1= 'refers' )? | 1358 | // InternalProblem.g:515:3: ( ( (lv_containment_0_0= 'contains' ) ) | otherlv_1= 'refers' )? |
1375 | int alt14=3; | 1359 | int alt14=3; |
1376 | int LA14_0 = input.LA(1); | 1360 | int LA14_0 = input.LA(1); |
1377 | 1361 | ||
@@ -1383,13 +1367,13 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1383 | } | 1367 | } |
1384 | switch (alt14) { | 1368 | switch (alt14) { |
1385 | case 1 : | 1369 | case 1 : |
1386 | // InternalProblem.g:507:4: ( (lv_containment_0_0= 'contains' ) ) | 1370 | // InternalProblem.g:516:4: ( (lv_containment_0_0= 'contains' ) ) |
1387 | { | 1371 | { |
1388 | // InternalProblem.g:507:4: ( (lv_containment_0_0= 'contains' ) ) | 1372 | // InternalProblem.g:516:4: ( (lv_containment_0_0= 'contains' ) ) |
1389 | // InternalProblem.g:508:5: (lv_containment_0_0= 'contains' ) | 1373 | // InternalProblem.g:517:5: (lv_containment_0_0= 'contains' ) |
1390 | { | 1374 | { |
1391 | // InternalProblem.g:508:5: (lv_containment_0_0= 'contains' ) | 1375 | // InternalProblem.g:517:5: (lv_containment_0_0= 'contains' ) |
1392 | // InternalProblem.g:509:6: lv_containment_0_0= 'contains' | 1376 | // InternalProblem.g:518:6: lv_containment_0_0= 'contains' |
1393 | { | 1377 | { |
1394 | lv_containment_0_0=(Token)match(input,22,FOLLOW_8); | 1378 | lv_containment_0_0=(Token)match(input,22,FOLLOW_8); |
1395 | 1379 | ||
@@ -1411,7 +1395,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1411 | } | 1395 | } |
1412 | break; | 1396 | break; |
1413 | case 2 : | 1397 | case 2 : |
1414 | // InternalProblem.g:522:4: otherlv_1= 'refers' | 1398 | // InternalProblem.g:531:4: otherlv_1= 'refers' |
1415 | { | 1399 | { |
1416 | otherlv_1=(Token)match(input,23,FOLLOW_8); | 1400 | otherlv_1=(Token)match(input,23,FOLLOW_8); |
1417 | 1401 | ||
@@ -1423,11 +1407,11 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1423 | 1407 | ||
1424 | } | 1408 | } |
1425 | 1409 | ||
1426 | // InternalProblem.g:527:3: ( ( ruleQualifiedName ) ) | 1410 | // InternalProblem.g:536:3: ( ( ruleQualifiedName ) ) |
1427 | // InternalProblem.g:528:4: ( ruleQualifiedName ) | 1411 | // InternalProblem.g:537:4: ( ruleQualifiedName ) |
1428 | { | 1412 | { |
1429 | // InternalProblem.g:528:4: ( ruleQualifiedName ) | 1413 | // InternalProblem.g:537:4: ( ruleQualifiedName ) |
1430 | // InternalProblem.g:529:5: ruleQualifiedName | 1414 | // InternalProblem.g:538:5: ruleQualifiedName |
1431 | { | 1415 | { |
1432 | 1416 | ||
1433 | if (current==null) { | 1417 | if (current==null) { |
@@ -1451,7 +1435,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1451 | 1435 | ||
1452 | } | 1436 | } |
1453 | 1437 | ||
1454 | // InternalProblem.g:543:3: (otherlv_3= '[' ( (lv_multiplicity_4_0= ruleMultiplicity ) ) otherlv_5= ']' )? | 1438 | // InternalProblem.g:552:3: (otherlv_3= '[' ( (lv_multiplicity_4_0= ruleMultiplicity ) ) otherlv_5= ']' )? |
1455 | int alt15=2; | 1439 | int alt15=2; |
1456 | int LA15_0 = input.LA(1); | 1440 | int LA15_0 = input.LA(1); |
1457 | 1441 | ||
@@ -1460,17 +1444,17 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1460 | } | 1444 | } |
1461 | switch (alt15) { | 1445 | switch (alt15) { |
1462 | case 1 : | 1446 | case 1 : |
1463 | // InternalProblem.g:544:4: otherlv_3= '[' ( (lv_multiplicity_4_0= ruleMultiplicity ) ) otherlv_5= ']' | 1447 | // InternalProblem.g:553:4: otherlv_3= '[' ( (lv_multiplicity_4_0= ruleMultiplicity ) ) otherlv_5= ']' |
1464 | { | 1448 | { |
1465 | otherlv_3=(Token)match(input,24,FOLLOW_17); | 1449 | otherlv_3=(Token)match(input,24,FOLLOW_17); |
1466 | 1450 | ||
1467 | newLeafNode(otherlv_3, grammarAccess.getReferenceDeclarationAccess().getLeftSquareBracketKeyword_2_0()); | 1451 | newLeafNode(otherlv_3, grammarAccess.getReferenceDeclarationAccess().getLeftSquareBracketKeyword_2_0()); |
1468 | 1452 | ||
1469 | // InternalProblem.g:548:4: ( (lv_multiplicity_4_0= ruleMultiplicity ) ) | 1453 | // InternalProblem.g:557:4: ( (lv_multiplicity_4_0= ruleMultiplicity ) ) |
1470 | // InternalProblem.g:549:5: (lv_multiplicity_4_0= ruleMultiplicity ) | 1454 | // InternalProblem.g:558:5: (lv_multiplicity_4_0= ruleMultiplicity ) |
1471 | { | 1455 | { |
1472 | // InternalProblem.g:549:5: (lv_multiplicity_4_0= ruleMultiplicity ) | 1456 | // InternalProblem.g:558:5: (lv_multiplicity_4_0= ruleMultiplicity ) |
1473 | // InternalProblem.g:550:6: lv_multiplicity_4_0= ruleMultiplicity | 1457 | // InternalProblem.g:559:6: lv_multiplicity_4_0= ruleMultiplicity |
1474 | { | 1458 | { |
1475 | 1459 | ||
1476 | newCompositeNode(grammarAccess.getReferenceDeclarationAccess().getMultiplicityMultiplicityParserRuleCall_2_1_0()); | 1460 | newCompositeNode(grammarAccess.getReferenceDeclarationAccess().getMultiplicityMultiplicityParserRuleCall_2_1_0()); |
@@ -1507,11 +1491,11 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1507 | 1491 | ||
1508 | } | 1492 | } |
1509 | 1493 | ||
1510 | // InternalProblem.g:572:3: ( (lv_name_6_0= ruleIdentifier ) ) | 1494 | // InternalProblem.g:581:3: ( (lv_name_6_0= ruleIdentifier ) ) |
1511 | // InternalProblem.g:573:4: (lv_name_6_0= ruleIdentifier ) | 1495 | // InternalProblem.g:582:4: (lv_name_6_0= ruleIdentifier ) |
1512 | { | 1496 | { |
1513 | // InternalProblem.g:573:4: (lv_name_6_0= ruleIdentifier ) | 1497 | // InternalProblem.g:582:4: (lv_name_6_0= ruleIdentifier ) |
1514 | // InternalProblem.g:574:5: lv_name_6_0= ruleIdentifier | 1498 | // InternalProblem.g:583:5: lv_name_6_0= ruleIdentifier |
1515 | { | 1499 | { |
1516 | 1500 | ||
1517 | newCompositeNode(grammarAccess.getReferenceDeclarationAccess().getNameIdentifierParserRuleCall_3_0()); | 1501 | newCompositeNode(grammarAccess.getReferenceDeclarationAccess().getNameIdentifierParserRuleCall_3_0()); |
@@ -1538,7 +1522,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1538 | 1522 | ||
1539 | } | 1523 | } |
1540 | 1524 | ||
1541 | // InternalProblem.g:591:3: (otherlv_7= 'opposite' ( ( ruleQualifiedName ) ) )? | 1525 | // InternalProblem.g:600:3: (otherlv_7= 'opposite' ( ( ruleQualifiedName ) ) )? |
1542 | int alt16=2; | 1526 | int alt16=2; |
1543 | int LA16_0 = input.LA(1); | 1527 | int LA16_0 = input.LA(1); |
1544 | 1528 | ||
@@ -1547,17 +1531,17 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1547 | } | 1531 | } |
1548 | switch (alt16) { | 1532 | switch (alt16) { |
1549 | case 1 : | 1533 | case 1 : |
1550 | // InternalProblem.g:592:4: otherlv_7= 'opposite' ( ( ruleQualifiedName ) ) | 1534 | // InternalProblem.g:601:4: otherlv_7= 'opposite' ( ( ruleQualifiedName ) ) |
1551 | { | 1535 | { |
1552 | otherlv_7=(Token)match(input,26,FOLLOW_8); | 1536 | otherlv_7=(Token)match(input,26,FOLLOW_8); |
1553 | 1537 | ||
1554 | newLeafNode(otherlv_7, grammarAccess.getReferenceDeclarationAccess().getOppositeKeyword_4_0()); | 1538 | newLeafNode(otherlv_7, grammarAccess.getReferenceDeclarationAccess().getOppositeKeyword_4_0()); |
1555 | 1539 | ||
1556 | // InternalProblem.g:596:4: ( ( ruleQualifiedName ) ) | 1540 | // InternalProblem.g:605:4: ( ( ruleQualifiedName ) ) |
1557 | // InternalProblem.g:597:5: ( ruleQualifiedName ) | 1541 | // InternalProblem.g:606:5: ( ruleQualifiedName ) |
1558 | { | 1542 | { |
1559 | // InternalProblem.g:597:5: ( ruleQualifiedName ) | 1543 | // InternalProblem.g:606:5: ( ruleQualifiedName ) |
1560 | // InternalProblem.g:598:6: ruleQualifiedName | 1544 | // InternalProblem.g:607:6: ruleQualifiedName |
1561 | { | 1545 | { |
1562 | 1546 | ||
1563 | if (current==null) { | 1547 | if (current==null) { |
@@ -1610,7 +1594,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1610 | 1594 | ||
1611 | 1595 | ||
1612 | // $ANTLR start "entryRulePredicateDefinition" | 1596 | // $ANTLR start "entryRulePredicateDefinition" |
1613 | // InternalProblem.g:617:1: entryRulePredicateDefinition returns [EObject current=null] : iv_rulePredicateDefinition= rulePredicateDefinition EOF ; | 1597 | // InternalProblem.g:626:1: entryRulePredicateDefinition returns [EObject current=null] : iv_rulePredicateDefinition= rulePredicateDefinition EOF ; |
1614 | public final EObject entryRulePredicateDefinition() throws RecognitionException { | 1598 | public final EObject entryRulePredicateDefinition() throws RecognitionException { |
1615 | EObject current = null; | 1599 | EObject current = null; |
1616 | 1600 | ||
@@ -1618,8 +1602,8 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1618 | 1602 | ||
1619 | 1603 | ||
1620 | try { | 1604 | try { |
1621 | // InternalProblem.g:617:60: (iv_rulePredicateDefinition= rulePredicateDefinition EOF ) | 1605 | // InternalProblem.g:626:60: (iv_rulePredicateDefinition= rulePredicateDefinition EOF ) |
1622 | // InternalProblem.g:618:2: iv_rulePredicateDefinition= rulePredicateDefinition EOF | 1606 | // InternalProblem.g:627:2: iv_rulePredicateDefinition= rulePredicateDefinition EOF |
1623 | { | 1607 | { |
1624 | newCompositeNode(grammarAccess.getPredicateDefinitionRule()); | 1608 | newCompositeNode(grammarAccess.getPredicateDefinitionRule()); |
1625 | pushFollow(FOLLOW_1); | 1609 | pushFollow(FOLLOW_1); |
@@ -1646,7 +1630,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1646 | 1630 | ||
1647 | 1631 | ||
1648 | // $ANTLR start "rulePredicateDefinition" | 1632 | // $ANTLR start "rulePredicateDefinition" |
1649 | // InternalProblem.g:624:1: rulePredicateDefinition returns [EObject current=null] : ( ( ( ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? ) | otherlv_2= 'pred' ) ( (lv_name_3_0= ruleIdentifier ) ) otherlv_4= '(' ( ( (lv_parameters_5_0= ruleParameter ) ) (otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) )* )? otherlv_8= ')' (otherlv_9= ':-' ( (lv_bodies_10_0= ruleConjunction ) ) (otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) )* )? otherlv_13= '.' ) ; | 1633 | // InternalProblem.g:633:1: rulePredicateDefinition returns [EObject current=null] : ( ( ( ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? ) | otherlv_2= 'pred' ) ( (lv_name_3_0= ruleIdentifier ) ) otherlv_4= '(' ( ( (lv_parameters_5_0= ruleParameter ) ) (otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) )* )? otherlv_8= ')' (otherlv_9= ':-' ( (lv_bodies_10_0= ruleConjunction ) ) (otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) )* )? otherlv_13= '.' ) ; |
1650 | public final EObject rulePredicateDefinition() throws RecognitionException { | 1634 | public final EObject rulePredicateDefinition() throws RecognitionException { |
1651 | EObject current = null; | 1635 | EObject current = null; |
1652 | 1636 | ||
@@ -1674,13 +1658,13 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1674 | enterRule(); | 1658 | enterRule(); |
1675 | 1659 | ||
1676 | try { | 1660 | try { |
1677 | // InternalProblem.g:630:2: ( ( ( ( ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? ) | otherlv_2= 'pred' ) ( (lv_name_3_0= ruleIdentifier ) ) otherlv_4= '(' ( ( (lv_parameters_5_0= ruleParameter ) ) (otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) )* )? otherlv_8= ')' (otherlv_9= ':-' ( (lv_bodies_10_0= ruleConjunction ) ) (otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) )* )? otherlv_13= '.' ) ) | 1661 | // InternalProblem.g:639:2: ( ( ( ( ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? ) | otherlv_2= 'pred' ) ( (lv_name_3_0= ruleIdentifier ) ) otherlv_4= '(' ( ( (lv_parameters_5_0= ruleParameter ) ) (otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) )* )? otherlv_8= ')' (otherlv_9= ':-' ( (lv_bodies_10_0= ruleConjunction ) ) (otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) )* )? otherlv_13= '.' ) ) |
1678 | // InternalProblem.g:631:2: ( ( ( ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? ) | otherlv_2= 'pred' ) ( (lv_name_3_0= ruleIdentifier ) ) otherlv_4= '(' ( ( (lv_parameters_5_0= ruleParameter ) ) (otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) )* )? otherlv_8= ')' (otherlv_9= ':-' ( (lv_bodies_10_0= ruleConjunction ) ) (otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) )* )? otherlv_13= '.' ) | 1662 | // InternalProblem.g:640:2: ( ( ( ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? ) | otherlv_2= 'pred' ) ( (lv_name_3_0= ruleIdentifier ) ) otherlv_4= '(' ( ( (lv_parameters_5_0= ruleParameter ) ) (otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) )* )? otherlv_8= ')' (otherlv_9= ':-' ( (lv_bodies_10_0= ruleConjunction ) ) (otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) )* )? otherlv_13= '.' ) |
1679 | { | 1663 | { |
1680 | // InternalProblem.g:631:2: ( ( ( ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? ) | otherlv_2= 'pred' ) ( (lv_name_3_0= ruleIdentifier ) ) otherlv_4= '(' ( ( (lv_parameters_5_0= ruleParameter ) ) (otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) )* )? otherlv_8= ')' (otherlv_9= ':-' ( (lv_bodies_10_0= ruleConjunction ) ) (otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) )* )? otherlv_13= '.' ) | 1664 | // InternalProblem.g:640:2: ( ( ( ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? ) | otherlv_2= 'pred' ) ( (lv_name_3_0= ruleIdentifier ) ) otherlv_4= '(' ( ( (lv_parameters_5_0= ruleParameter ) ) (otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) )* )? otherlv_8= ')' (otherlv_9= ':-' ( (lv_bodies_10_0= ruleConjunction ) ) (otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) )* )? otherlv_13= '.' ) |
1681 | // InternalProblem.g:632:3: ( ( ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? ) | otherlv_2= 'pred' ) ( (lv_name_3_0= ruleIdentifier ) ) otherlv_4= '(' ( ( (lv_parameters_5_0= ruleParameter ) ) (otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) )* )? otherlv_8= ')' (otherlv_9= ':-' ( (lv_bodies_10_0= ruleConjunction ) ) (otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) )* )? otherlv_13= '.' | 1665 | // InternalProblem.g:641:3: ( ( ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? ) | otherlv_2= 'pred' ) ( (lv_name_3_0= ruleIdentifier ) ) otherlv_4= '(' ( ( (lv_parameters_5_0= ruleParameter ) ) (otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) )* )? otherlv_8= ')' (otherlv_9= ':-' ( (lv_bodies_10_0= ruleConjunction ) ) (otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) )* )? otherlv_13= '.' |
1682 | { | 1666 | { |
1683 | // InternalProblem.g:632:3: ( ( ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? ) | otherlv_2= 'pred' ) | 1667 | // InternalProblem.g:641:3: ( ( ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? ) | otherlv_2= 'pred' ) |
1684 | int alt18=2; | 1668 | int alt18=2; |
1685 | int LA18_0 = input.LA(1); | 1669 | int LA18_0 = input.LA(1); |
1686 | 1670 | ||
@@ -1698,16 +1682,16 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1698 | } | 1682 | } |
1699 | switch (alt18) { | 1683 | switch (alt18) { |
1700 | case 1 : | 1684 | case 1 : |
1701 | // InternalProblem.g:633:4: ( ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? ) | 1685 | // InternalProblem.g:642:4: ( ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? ) |
1702 | { | 1686 | { |
1703 | // InternalProblem.g:633:4: ( ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? ) | 1687 | // InternalProblem.g:642:4: ( ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? ) |
1704 | // InternalProblem.g:634:5: ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? | 1688 | // InternalProblem.g:643:5: ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? |
1705 | { | 1689 | { |
1706 | // InternalProblem.g:634:5: ( (lv_error_0_0= 'error' ) ) | 1690 | // InternalProblem.g:643:5: ( (lv_error_0_0= 'error' ) ) |
1707 | // InternalProblem.g:635:6: (lv_error_0_0= 'error' ) | 1691 | // InternalProblem.g:644:6: (lv_error_0_0= 'error' ) |
1708 | { | 1692 | { |
1709 | // InternalProblem.g:635:6: (lv_error_0_0= 'error' ) | 1693 | // InternalProblem.g:644:6: (lv_error_0_0= 'error' ) |
1710 | // InternalProblem.g:636:7: lv_error_0_0= 'error' | 1694 | // InternalProblem.g:645:7: lv_error_0_0= 'error' |
1711 | { | 1695 | { |
1712 | lv_error_0_0=(Token)match(input,27,FOLLOW_20); | 1696 | lv_error_0_0=(Token)match(input,27,FOLLOW_20); |
1713 | 1697 | ||
@@ -1725,7 +1709,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1725 | 1709 | ||
1726 | } | 1710 | } |
1727 | 1711 | ||
1728 | // InternalProblem.g:648:5: (otherlv_1= 'pred' )? | 1712 | // InternalProblem.g:657:5: (otherlv_1= 'pred' )? |
1729 | int alt17=2; | 1713 | int alt17=2; |
1730 | int LA17_0 = input.LA(1); | 1714 | int LA17_0 = input.LA(1); |
1731 | 1715 | ||
@@ -1734,7 +1718,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1734 | } | 1718 | } |
1735 | switch (alt17) { | 1719 | switch (alt17) { |
1736 | case 1 : | 1720 | case 1 : |
1737 | // InternalProblem.g:649:6: otherlv_1= 'pred' | 1721 | // InternalProblem.g:658:6: otherlv_1= 'pred' |
1738 | { | 1722 | { |
1739 | otherlv_1=(Token)match(input,28,FOLLOW_3); | 1723 | otherlv_1=(Token)match(input,28,FOLLOW_3); |
1740 | 1724 | ||
@@ -1753,7 +1737,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1753 | } | 1737 | } |
1754 | break; | 1738 | break; |
1755 | case 2 : | 1739 | case 2 : |
1756 | // InternalProblem.g:656:4: otherlv_2= 'pred' | 1740 | // InternalProblem.g:665:4: otherlv_2= 'pred' |
1757 | { | 1741 | { |
1758 | otherlv_2=(Token)match(input,28,FOLLOW_3); | 1742 | otherlv_2=(Token)match(input,28,FOLLOW_3); |
1759 | 1743 | ||
@@ -1765,11 +1749,11 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1765 | 1749 | ||
1766 | } | 1750 | } |
1767 | 1751 | ||
1768 | // InternalProblem.g:661:3: ( (lv_name_3_0= ruleIdentifier ) ) | 1752 | // InternalProblem.g:670:3: ( (lv_name_3_0= ruleIdentifier ) ) |
1769 | // InternalProblem.g:662:4: (lv_name_3_0= ruleIdentifier ) | 1753 | // InternalProblem.g:671:4: (lv_name_3_0= ruleIdentifier ) |
1770 | { | 1754 | { |
1771 | // InternalProblem.g:662:4: (lv_name_3_0= ruleIdentifier ) | 1755 | // InternalProblem.g:671:4: (lv_name_3_0= ruleIdentifier ) |
1772 | // InternalProblem.g:663:5: lv_name_3_0= ruleIdentifier | 1756 | // InternalProblem.g:672:5: lv_name_3_0= ruleIdentifier |
1773 | { | 1757 | { |
1774 | 1758 | ||
1775 | newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getNameIdentifierParserRuleCall_1_0()); | 1759 | newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getNameIdentifierParserRuleCall_1_0()); |
@@ -1800,22 +1784,22 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1800 | 1784 | ||
1801 | newLeafNode(otherlv_4, grammarAccess.getPredicateDefinitionAccess().getLeftParenthesisKeyword_2()); | 1785 | newLeafNode(otherlv_4, grammarAccess.getPredicateDefinitionAccess().getLeftParenthesisKeyword_2()); |
1802 | 1786 | ||
1803 | // InternalProblem.g:684:3: ( ( (lv_parameters_5_0= ruleParameter ) ) (otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) )* )? | 1787 | // InternalProblem.g:693:3: ( ( (lv_parameters_5_0= ruleParameter ) ) (otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) )* )? |
1804 | int alt20=2; | 1788 | int alt20=2; |
1805 | int LA20_0 = input.LA(1); | 1789 | int LA20_0 = input.LA(1); |
1806 | 1790 | ||
1807 | if ( (LA20_0==RULE_ID||LA20_0==RULE_QUOTED_ID||(LA20_0>=41 && LA20_0<=42)) ) { | 1791 | if ( (LA20_0==RULE_ID||LA20_0==RULE_QUOTED_ID||(LA20_0>=41 && LA20_0<=44)) ) { |
1808 | alt20=1; | 1792 | alt20=1; |
1809 | } | 1793 | } |
1810 | switch (alt20) { | 1794 | switch (alt20) { |
1811 | case 1 : | 1795 | case 1 : |
1812 | // InternalProblem.g:685:4: ( (lv_parameters_5_0= ruleParameter ) ) (otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) )* | 1796 | // InternalProblem.g:694:4: ( (lv_parameters_5_0= ruleParameter ) ) (otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) )* |
1813 | { | 1797 | { |
1814 | // InternalProblem.g:685:4: ( (lv_parameters_5_0= ruleParameter ) ) | 1798 | // InternalProblem.g:694:4: ( (lv_parameters_5_0= ruleParameter ) ) |
1815 | // InternalProblem.g:686:5: (lv_parameters_5_0= ruleParameter ) | 1799 | // InternalProblem.g:695:5: (lv_parameters_5_0= ruleParameter ) |
1816 | { | 1800 | { |
1817 | // InternalProblem.g:686:5: (lv_parameters_5_0= ruleParameter ) | 1801 | // InternalProblem.g:695:5: (lv_parameters_5_0= ruleParameter ) |
1818 | // InternalProblem.g:687:6: lv_parameters_5_0= ruleParameter | 1802 | // InternalProblem.g:696:6: lv_parameters_5_0= ruleParameter |
1819 | { | 1803 | { |
1820 | 1804 | ||
1821 | newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getParametersParameterParserRuleCall_3_0_0()); | 1805 | newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getParametersParameterParserRuleCall_3_0_0()); |
@@ -1842,7 +1826,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1842 | 1826 | ||
1843 | } | 1827 | } |
1844 | 1828 | ||
1845 | // InternalProblem.g:704:4: (otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) )* | 1829 | // InternalProblem.g:713:4: (otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) )* |
1846 | loop19: | 1830 | loop19: |
1847 | do { | 1831 | do { |
1848 | int alt19=2; | 1832 | int alt19=2; |
@@ -1855,17 +1839,17 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1855 | 1839 | ||
1856 | switch (alt19) { | 1840 | switch (alt19) { |
1857 | case 1 : | 1841 | case 1 : |
1858 | // InternalProblem.g:705:5: otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) | 1842 | // InternalProblem.g:714:5: otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) |
1859 | { | 1843 | { |
1860 | otherlv_6=(Token)match(input,17,FOLLOW_8); | 1844 | otherlv_6=(Token)match(input,17,FOLLOW_8); |
1861 | 1845 | ||
1862 | newLeafNode(otherlv_6, grammarAccess.getPredicateDefinitionAccess().getCommaKeyword_3_1_0()); | 1846 | newLeafNode(otherlv_6, grammarAccess.getPredicateDefinitionAccess().getCommaKeyword_3_1_0()); |
1863 | 1847 | ||
1864 | // InternalProblem.g:709:5: ( (lv_parameters_7_0= ruleParameter ) ) | 1848 | // InternalProblem.g:718:5: ( (lv_parameters_7_0= ruleParameter ) ) |
1865 | // InternalProblem.g:710:6: (lv_parameters_7_0= ruleParameter ) | 1849 | // InternalProblem.g:719:6: (lv_parameters_7_0= ruleParameter ) |
1866 | { | 1850 | { |
1867 | // InternalProblem.g:710:6: (lv_parameters_7_0= ruleParameter ) | 1851 | // InternalProblem.g:719:6: (lv_parameters_7_0= ruleParameter ) |
1868 | // InternalProblem.g:711:7: lv_parameters_7_0= ruleParameter | 1852 | // InternalProblem.g:720:7: lv_parameters_7_0= ruleParameter |
1869 | { | 1853 | { |
1870 | 1854 | ||
1871 | newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getParametersParameterParserRuleCall_3_1_1_0()); | 1855 | newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getParametersParameterParserRuleCall_3_1_1_0()); |
@@ -1911,7 +1895,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1911 | 1895 | ||
1912 | newLeafNode(otherlv_8, grammarAccess.getPredicateDefinitionAccess().getRightParenthesisKeyword_4()); | 1896 | newLeafNode(otherlv_8, grammarAccess.getPredicateDefinitionAccess().getRightParenthesisKeyword_4()); |
1913 | 1897 | ||
1914 | // InternalProblem.g:734:3: (otherlv_9= ':-' ( (lv_bodies_10_0= ruleConjunction ) ) (otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) )* )? | 1898 | // InternalProblem.g:743:3: (otherlv_9= ':-' ( (lv_bodies_10_0= ruleConjunction ) ) (otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) )* )? |
1915 | int alt22=2; | 1899 | int alt22=2; |
1916 | int LA22_0 = input.LA(1); | 1900 | int LA22_0 = input.LA(1); |
1917 | 1901 | ||
@@ -1920,17 +1904,17 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1920 | } | 1904 | } |
1921 | switch (alt22) { | 1905 | switch (alt22) { |
1922 | case 1 : | 1906 | case 1 : |
1923 | // InternalProblem.g:735:4: otherlv_9= ':-' ( (lv_bodies_10_0= ruleConjunction ) ) (otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) )* | 1907 | // InternalProblem.g:744:4: otherlv_9= ':-' ( (lv_bodies_10_0= ruleConjunction ) ) (otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) )* |
1924 | { | 1908 | { |
1925 | otherlv_9=(Token)match(input,31,FOLLOW_25); | 1909 | otherlv_9=(Token)match(input,31,FOLLOW_25); |
1926 | 1910 | ||
1927 | newLeafNode(otherlv_9, grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_5_0()); | 1911 | newLeafNode(otherlv_9, grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_5_0()); |
1928 | 1912 | ||
1929 | // InternalProblem.g:739:4: ( (lv_bodies_10_0= ruleConjunction ) ) | 1913 | // InternalProblem.g:748:4: ( (lv_bodies_10_0= ruleConjunction ) ) |
1930 | // InternalProblem.g:740:5: (lv_bodies_10_0= ruleConjunction ) | 1914 | // InternalProblem.g:749:5: (lv_bodies_10_0= ruleConjunction ) |
1931 | { | 1915 | { |
1932 | // InternalProblem.g:740:5: (lv_bodies_10_0= ruleConjunction ) | 1916 | // InternalProblem.g:749:5: (lv_bodies_10_0= ruleConjunction ) |
1933 | // InternalProblem.g:741:6: lv_bodies_10_0= ruleConjunction | 1917 | // InternalProblem.g:750:6: lv_bodies_10_0= ruleConjunction |
1934 | { | 1918 | { |
1935 | 1919 | ||
1936 | newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getBodiesConjunctionParserRuleCall_5_1_0()); | 1920 | newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getBodiesConjunctionParserRuleCall_5_1_0()); |
@@ -1957,7 +1941,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1957 | 1941 | ||
1958 | } | 1942 | } |
1959 | 1943 | ||
1960 | // InternalProblem.g:758:4: (otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) )* | 1944 | // InternalProblem.g:767:4: (otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) )* |
1961 | loop21: | 1945 | loop21: |
1962 | do { | 1946 | do { |
1963 | int alt21=2; | 1947 | int alt21=2; |
@@ -1970,17 +1954,17 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
1970 | 1954 | ||
1971 | switch (alt21) { | 1955 | switch (alt21) { |
1972 | case 1 : | 1956 | case 1 : |
1973 | // InternalProblem.g:759:5: otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) | 1957 | // InternalProblem.g:768:5: otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) |
1974 | { | 1958 | { |
1975 | otherlv_11=(Token)match(input,19,FOLLOW_25); | 1959 | otherlv_11=(Token)match(input,19,FOLLOW_25); |
1976 | 1960 | ||
1977 | newLeafNode(otherlv_11, grammarAccess.getPredicateDefinitionAccess().getSemicolonKeyword_5_2_0()); | 1961 | newLeafNode(otherlv_11, grammarAccess.getPredicateDefinitionAccess().getSemicolonKeyword_5_2_0()); |
1978 | 1962 | ||
1979 | // InternalProblem.g:763:5: ( (lv_bodies_12_0= ruleConjunction ) ) | 1963 | // InternalProblem.g:772:5: ( (lv_bodies_12_0= ruleConjunction ) ) |
1980 | // InternalProblem.g:764:6: (lv_bodies_12_0= ruleConjunction ) | 1964 | // InternalProblem.g:773:6: (lv_bodies_12_0= ruleConjunction ) |
1981 | { | 1965 | { |
1982 | // InternalProblem.g:764:6: (lv_bodies_12_0= ruleConjunction ) | 1966 | // InternalProblem.g:773:6: (lv_bodies_12_0= ruleConjunction ) |
1983 | // InternalProblem.g:765:7: lv_bodies_12_0= ruleConjunction | 1967 | // InternalProblem.g:774:7: lv_bodies_12_0= ruleConjunction |
1984 | { | 1968 | { |
1985 | 1969 | ||
1986 | newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getBodiesConjunctionParserRuleCall_5_2_1_0()); | 1970 | newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getBodiesConjunctionParserRuleCall_5_2_1_0()); |
@@ -2049,7 +2033,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2049 | 2033 | ||
2050 | 2034 | ||
2051 | // $ANTLR start "entryRuleParameter" | 2035 | // $ANTLR start "entryRuleParameter" |
2052 | // InternalProblem.g:792:1: entryRuleParameter returns [EObject current=null] : iv_ruleParameter= ruleParameter EOF ; | 2036 | // InternalProblem.g:801:1: entryRuleParameter returns [EObject current=null] : iv_ruleParameter= ruleParameter EOF ; |
2053 | public final EObject entryRuleParameter() throws RecognitionException { | 2037 | public final EObject entryRuleParameter() throws RecognitionException { |
2054 | EObject current = null; | 2038 | EObject current = null; |
2055 | 2039 | ||
@@ -2057,8 +2041,8 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2057 | 2041 | ||
2058 | 2042 | ||
2059 | try { | 2043 | try { |
2060 | // InternalProblem.g:792:50: (iv_ruleParameter= ruleParameter EOF ) | 2044 | // InternalProblem.g:801:50: (iv_ruleParameter= ruleParameter EOF ) |
2061 | // InternalProblem.g:793:2: iv_ruleParameter= ruleParameter EOF | 2045 | // InternalProblem.g:802:2: iv_ruleParameter= ruleParameter EOF |
2062 | { | 2046 | { |
2063 | newCompositeNode(grammarAccess.getParameterRule()); | 2047 | newCompositeNode(grammarAccess.getParameterRule()); |
2064 | pushFollow(FOLLOW_1); | 2048 | pushFollow(FOLLOW_1); |
@@ -2085,7 +2069,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2085 | 2069 | ||
2086 | 2070 | ||
2087 | // $ANTLR start "ruleParameter" | 2071 | // $ANTLR start "ruleParameter" |
2088 | // InternalProblem.g:799:1: ruleParameter returns [EObject current=null] : ( ( ( ruleQualifiedName ) )? ( (lv_name_1_0= ruleIdentifier ) ) ) ; | 2072 | // InternalProblem.g:808:1: ruleParameter returns [EObject current=null] : ( ( ( ruleQualifiedName ) )? ( (lv_name_1_0= ruleIdentifier ) ) ) ; |
2089 | public final EObject ruleParameter() throws RecognitionException { | 2073 | public final EObject ruleParameter() throws RecognitionException { |
2090 | EObject current = null; | 2074 | EObject current = null; |
2091 | 2075 | ||
@@ -2096,13 +2080,13 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2096 | enterRule(); | 2080 | enterRule(); |
2097 | 2081 | ||
2098 | try { | 2082 | try { |
2099 | // InternalProblem.g:805:2: ( ( ( ( ruleQualifiedName ) )? ( (lv_name_1_0= ruleIdentifier ) ) ) ) | 2083 | // InternalProblem.g:814:2: ( ( ( ( ruleQualifiedName ) )? ( (lv_name_1_0= ruleIdentifier ) ) ) ) |
2100 | // InternalProblem.g:806:2: ( ( ( ruleQualifiedName ) )? ( (lv_name_1_0= ruleIdentifier ) ) ) | 2084 | // InternalProblem.g:815:2: ( ( ( ruleQualifiedName ) )? ( (lv_name_1_0= ruleIdentifier ) ) ) |
2101 | { | 2085 | { |
2102 | // InternalProblem.g:806:2: ( ( ( ruleQualifiedName ) )? ( (lv_name_1_0= ruleIdentifier ) ) ) | 2086 | // InternalProblem.g:815:2: ( ( ( ruleQualifiedName ) )? ( (lv_name_1_0= ruleIdentifier ) ) ) |
2103 | // InternalProblem.g:807:3: ( ( ruleQualifiedName ) )? ( (lv_name_1_0= ruleIdentifier ) ) | 2087 | // InternalProblem.g:816:3: ( ( ruleQualifiedName ) )? ( (lv_name_1_0= ruleIdentifier ) ) |
2104 | { | 2088 | { |
2105 | // InternalProblem.g:807:3: ( ( ruleQualifiedName ) )? | 2089 | // InternalProblem.g:816:3: ( ( ruleQualifiedName ) )? |
2106 | int alt23=2; | 2090 | int alt23=2; |
2107 | switch ( input.LA(1) ) { | 2091 | switch ( input.LA(1) ) { |
2108 | case RULE_QUOTED_ID: | 2092 | case RULE_QUOTED_ID: |
@@ -2114,7 +2098,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2114 | { | 2098 | { |
2115 | int LA23_2 = input.LA(2); | 2099 | int LA23_2 = input.LA(2); |
2116 | 2100 | ||
2117 | if ( (LA23_2==RULE_ID||(LA23_2>=40 && LA23_2<=42)) ) { | 2101 | if ( (LA23_2==RULE_ID||(LA23_2>=40 && LA23_2<=44)) ) { |
2118 | alt23=1; | 2102 | alt23=1; |
2119 | } | 2103 | } |
2120 | } | 2104 | } |
@@ -2123,7 +2107,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2123 | { | 2107 | { |
2124 | int LA23_3 = input.LA(2); | 2108 | int LA23_3 = input.LA(2); |
2125 | 2109 | ||
2126 | if ( (LA23_3==RULE_ID||(LA23_3>=40 && LA23_3<=42)) ) { | 2110 | if ( (LA23_3==RULE_ID||(LA23_3>=40 && LA23_3<=44)) ) { |
2127 | alt23=1; | 2111 | alt23=1; |
2128 | } | 2112 | } |
2129 | } | 2113 | } |
@@ -2132,7 +2116,25 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2132 | { | 2116 | { |
2133 | int LA23_4 = input.LA(2); | 2117 | int LA23_4 = input.LA(2); |
2134 | 2118 | ||
2135 | if ( (LA23_4==RULE_ID||(LA23_4>=40 && LA23_4<=42)) ) { | 2119 | if ( (LA23_4==RULE_ID||(LA23_4>=40 && LA23_4<=44)) ) { |
2120 | alt23=1; | ||
2121 | } | ||
2122 | } | ||
2123 | break; | ||
2124 | case 43: | ||
2125 | { | ||
2126 | int LA23_5 = input.LA(2); | ||
2127 | |||
2128 | if ( (LA23_5==RULE_ID||(LA23_5>=40 && LA23_5<=44)) ) { | ||
2129 | alt23=1; | ||
2130 | } | ||
2131 | } | ||
2132 | break; | ||
2133 | case 44: | ||
2134 | { | ||
2135 | int LA23_6 = input.LA(2); | ||
2136 | |||
2137 | if ( (LA23_6==RULE_ID||(LA23_6>=40 && LA23_6<=44)) ) { | ||
2136 | alt23=1; | 2138 | alt23=1; |
2137 | } | 2139 | } |
2138 | } | 2140 | } |
@@ -2141,10 +2143,10 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2141 | 2143 | ||
2142 | switch (alt23) { | 2144 | switch (alt23) { |
2143 | case 1 : | 2145 | case 1 : |
2144 | // InternalProblem.g:808:4: ( ruleQualifiedName ) | 2146 | // InternalProblem.g:817:4: ( ruleQualifiedName ) |
2145 | { | 2147 | { |
2146 | // InternalProblem.g:808:4: ( ruleQualifiedName ) | 2148 | // InternalProblem.g:817:4: ( ruleQualifiedName ) |
2147 | // InternalProblem.g:809:5: ruleQualifiedName | 2149 | // InternalProblem.g:818:5: ruleQualifiedName |
2148 | { | 2150 | { |
2149 | 2151 | ||
2150 | if (current==null) { | 2152 | if (current==null) { |
@@ -2171,11 +2173,11 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2171 | 2173 | ||
2172 | } | 2174 | } |
2173 | 2175 | ||
2174 | // InternalProblem.g:823:3: ( (lv_name_1_0= ruleIdentifier ) ) | 2176 | // InternalProblem.g:832:3: ( (lv_name_1_0= ruleIdentifier ) ) |
2175 | // InternalProblem.g:824:4: (lv_name_1_0= ruleIdentifier ) | 2177 | // InternalProblem.g:833:4: (lv_name_1_0= ruleIdentifier ) |
2176 | { | 2178 | { |
2177 | // InternalProblem.g:824:4: (lv_name_1_0= ruleIdentifier ) | 2179 | // InternalProblem.g:833:4: (lv_name_1_0= ruleIdentifier ) |
2178 | // InternalProblem.g:825:5: lv_name_1_0= ruleIdentifier | 2180 | // InternalProblem.g:834:5: lv_name_1_0= ruleIdentifier |
2179 | { | 2181 | { |
2180 | 2182 | ||
2181 | newCompositeNode(grammarAccess.getParameterAccess().getNameIdentifierParserRuleCall_1_0()); | 2183 | newCompositeNode(grammarAccess.getParameterAccess().getNameIdentifierParserRuleCall_1_0()); |
@@ -2225,7 +2227,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2225 | 2227 | ||
2226 | 2228 | ||
2227 | // $ANTLR start "entryRuleConjunction" | 2229 | // $ANTLR start "entryRuleConjunction" |
2228 | // InternalProblem.g:846:1: entryRuleConjunction returns [EObject current=null] : iv_ruleConjunction= ruleConjunction EOF ; | 2230 | // InternalProblem.g:855:1: entryRuleConjunction returns [EObject current=null] : iv_ruleConjunction= ruleConjunction EOF ; |
2229 | public final EObject entryRuleConjunction() throws RecognitionException { | 2231 | public final EObject entryRuleConjunction() throws RecognitionException { |
2230 | EObject current = null; | 2232 | EObject current = null; |
2231 | 2233 | ||
@@ -2233,8 +2235,8 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2233 | 2235 | ||
2234 | 2236 | ||
2235 | try { | 2237 | try { |
2236 | // InternalProblem.g:846:52: (iv_ruleConjunction= ruleConjunction EOF ) | 2238 | // InternalProblem.g:855:52: (iv_ruleConjunction= ruleConjunction EOF ) |
2237 | // InternalProblem.g:847:2: iv_ruleConjunction= ruleConjunction EOF | 2239 | // InternalProblem.g:856:2: iv_ruleConjunction= ruleConjunction EOF |
2238 | { | 2240 | { |
2239 | newCompositeNode(grammarAccess.getConjunctionRule()); | 2241 | newCompositeNode(grammarAccess.getConjunctionRule()); |
2240 | pushFollow(FOLLOW_1); | 2242 | pushFollow(FOLLOW_1); |
@@ -2261,7 +2263,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2261 | 2263 | ||
2262 | 2264 | ||
2263 | // $ANTLR start "ruleConjunction" | 2265 | // $ANTLR start "ruleConjunction" |
2264 | // InternalProblem.g:853:1: ruleConjunction returns [EObject current=null] : ( ( (lv_literals_0_0= ruleLiteral ) ) (otherlv_1= ',' ( (lv_literals_2_0= ruleLiteral ) ) )* ) ; | 2266 | // InternalProblem.g:862:1: ruleConjunction returns [EObject current=null] : ( ( (lv_literals_0_0= ruleLiteral ) ) (otherlv_1= ',' ( (lv_literals_2_0= ruleLiteral ) ) )* ) ; |
2265 | public final EObject ruleConjunction() throws RecognitionException { | 2267 | public final EObject ruleConjunction() throws RecognitionException { |
2266 | EObject current = null; | 2268 | EObject current = null; |
2267 | 2269 | ||
@@ -2275,17 +2277,17 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2275 | enterRule(); | 2277 | enterRule(); |
2276 | 2278 | ||
2277 | try { | 2279 | try { |
2278 | // InternalProblem.g:859:2: ( ( ( (lv_literals_0_0= ruleLiteral ) ) (otherlv_1= ',' ( (lv_literals_2_0= ruleLiteral ) ) )* ) ) | 2280 | // InternalProblem.g:868:2: ( ( ( (lv_literals_0_0= ruleLiteral ) ) (otherlv_1= ',' ( (lv_literals_2_0= ruleLiteral ) ) )* ) ) |
2279 | // InternalProblem.g:860:2: ( ( (lv_literals_0_0= ruleLiteral ) ) (otherlv_1= ',' ( (lv_literals_2_0= ruleLiteral ) ) )* ) | 2281 | // InternalProblem.g:869:2: ( ( (lv_literals_0_0= ruleLiteral ) ) (otherlv_1= ',' ( (lv_literals_2_0= ruleLiteral ) ) )* ) |
2280 | { | 2282 | { |
2281 | // InternalProblem.g:860:2: ( ( (lv_literals_0_0= ruleLiteral ) ) (otherlv_1= ',' ( (lv_literals_2_0= ruleLiteral ) ) )* ) | 2283 | // InternalProblem.g:869:2: ( ( (lv_literals_0_0= ruleLiteral ) ) (otherlv_1= ',' ( (lv_literals_2_0= ruleLiteral ) ) )* ) |
2282 | // InternalProblem.g:861:3: ( (lv_literals_0_0= ruleLiteral ) ) (otherlv_1= ',' ( (lv_literals_2_0= ruleLiteral ) ) )* | 2284 | // InternalProblem.g:870:3: ( (lv_literals_0_0= ruleLiteral ) ) (otherlv_1= ',' ( (lv_literals_2_0= ruleLiteral ) ) )* |
2283 | { | 2285 | { |
2284 | // InternalProblem.g:861:3: ( (lv_literals_0_0= ruleLiteral ) ) | 2286 | // InternalProblem.g:870:3: ( (lv_literals_0_0= ruleLiteral ) ) |
2285 | // InternalProblem.g:862:4: (lv_literals_0_0= ruleLiteral ) | 2287 | // InternalProblem.g:871:4: (lv_literals_0_0= ruleLiteral ) |
2286 | { | 2288 | { |
2287 | // InternalProblem.g:862:4: (lv_literals_0_0= ruleLiteral ) | 2289 | // InternalProblem.g:871:4: (lv_literals_0_0= ruleLiteral ) |
2288 | // InternalProblem.g:863:5: lv_literals_0_0= ruleLiteral | 2290 | // InternalProblem.g:872:5: lv_literals_0_0= ruleLiteral |
2289 | { | 2291 | { |
2290 | 2292 | ||
2291 | newCompositeNode(grammarAccess.getConjunctionAccess().getLiteralsLiteralParserRuleCall_0_0()); | 2293 | newCompositeNode(grammarAccess.getConjunctionAccess().getLiteralsLiteralParserRuleCall_0_0()); |
@@ -2312,7 +2314,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2312 | 2314 | ||
2313 | } | 2315 | } |
2314 | 2316 | ||
2315 | // InternalProblem.g:880:3: (otherlv_1= ',' ( (lv_literals_2_0= ruleLiteral ) ) )* | 2317 | // InternalProblem.g:889:3: (otherlv_1= ',' ( (lv_literals_2_0= ruleLiteral ) ) )* |
2316 | loop24: | 2318 | loop24: |
2317 | do { | 2319 | do { |
2318 | int alt24=2; | 2320 | int alt24=2; |
@@ -2325,17 +2327,17 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2325 | 2327 | ||
2326 | switch (alt24) { | 2328 | switch (alt24) { |
2327 | case 1 : | 2329 | case 1 : |
2328 | // InternalProblem.g:881:4: otherlv_1= ',' ( (lv_literals_2_0= ruleLiteral ) ) | 2330 | // InternalProblem.g:890:4: otherlv_1= ',' ( (lv_literals_2_0= ruleLiteral ) ) |
2329 | { | 2331 | { |
2330 | otherlv_1=(Token)match(input,17,FOLLOW_25); | 2332 | otherlv_1=(Token)match(input,17,FOLLOW_25); |
2331 | 2333 | ||
2332 | newLeafNode(otherlv_1, grammarAccess.getConjunctionAccess().getCommaKeyword_1_0()); | 2334 | newLeafNode(otherlv_1, grammarAccess.getConjunctionAccess().getCommaKeyword_1_0()); |
2333 | 2335 | ||
2334 | // InternalProblem.g:885:4: ( (lv_literals_2_0= ruleLiteral ) ) | 2336 | // InternalProblem.g:894:4: ( (lv_literals_2_0= ruleLiteral ) ) |
2335 | // InternalProblem.g:886:5: (lv_literals_2_0= ruleLiteral ) | 2337 | // InternalProblem.g:895:5: (lv_literals_2_0= ruleLiteral ) |
2336 | { | 2338 | { |
2337 | // InternalProblem.g:886:5: (lv_literals_2_0= ruleLiteral ) | 2339 | // InternalProblem.g:895:5: (lv_literals_2_0= ruleLiteral ) |
2338 | // InternalProblem.g:887:6: lv_literals_2_0= ruleLiteral | 2340 | // InternalProblem.g:896:6: lv_literals_2_0= ruleLiteral |
2339 | { | 2341 | { |
2340 | 2342 | ||
2341 | newCompositeNode(grammarAccess.getConjunctionAccess().getLiteralsLiteralParserRuleCall_1_1_0()); | 2343 | newCompositeNode(grammarAccess.getConjunctionAccess().getLiteralsLiteralParserRuleCall_1_1_0()); |
@@ -2394,7 +2396,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2394 | 2396 | ||
2395 | 2397 | ||
2396 | // $ANTLR start "entryRuleLiteral" | 2398 | // $ANTLR start "entryRuleLiteral" |
2397 | // InternalProblem.g:909:1: entryRuleLiteral returns [EObject current=null] : iv_ruleLiteral= ruleLiteral EOF ; | 2399 | // InternalProblem.g:918:1: entryRuleLiteral returns [EObject current=null] : iv_ruleLiteral= ruleLiteral EOF ; |
2398 | public final EObject entryRuleLiteral() throws RecognitionException { | 2400 | public final EObject entryRuleLiteral() throws RecognitionException { |
2399 | EObject current = null; | 2401 | EObject current = null; |
2400 | 2402 | ||
@@ -2402,8 +2404,8 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2402 | 2404 | ||
2403 | 2405 | ||
2404 | try { | 2406 | try { |
2405 | // InternalProblem.g:909:48: (iv_ruleLiteral= ruleLiteral EOF ) | 2407 | // InternalProblem.g:918:48: (iv_ruleLiteral= ruleLiteral EOF ) |
2406 | // InternalProblem.g:910:2: iv_ruleLiteral= ruleLiteral EOF | 2408 | // InternalProblem.g:919:2: iv_ruleLiteral= ruleLiteral EOF |
2407 | { | 2409 | { |
2408 | newCompositeNode(grammarAccess.getLiteralRule()); | 2410 | newCompositeNode(grammarAccess.getLiteralRule()); |
2409 | pushFollow(FOLLOW_1); | 2411 | pushFollow(FOLLOW_1); |
@@ -2430,7 +2432,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2430 | 2432 | ||
2431 | 2433 | ||
2432 | // $ANTLR start "ruleLiteral" | 2434 | // $ANTLR start "ruleLiteral" |
2433 | // InternalProblem.g:916:1: ruleLiteral returns [EObject current=null] : (this_Atom_0= ruleAtom | this_NegativeLiteral_1= ruleNegativeLiteral ) ; | 2435 | // InternalProblem.g:925:1: ruleLiteral returns [EObject current=null] : (this_Atom_0= ruleAtom | this_NegativeLiteral_1= ruleNegativeLiteral ) ; |
2434 | public final EObject ruleLiteral() throws RecognitionException { | 2436 | public final EObject ruleLiteral() throws RecognitionException { |
2435 | EObject current = null; | 2437 | EObject current = null; |
2436 | 2438 | ||
@@ -2443,14 +2445,14 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2443 | enterRule(); | 2445 | enterRule(); |
2444 | 2446 | ||
2445 | try { | 2447 | try { |
2446 | // InternalProblem.g:922:2: ( (this_Atom_0= ruleAtom | this_NegativeLiteral_1= ruleNegativeLiteral ) ) | 2448 | // InternalProblem.g:931:2: ( (this_Atom_0= ruleAtom | this_NegativeLiteral_1= ruleNegativeLiteral ) ) |
2447 | // InternalProblem.g:923:2: (this_Atom_0= ruleAtom | this_NegativeLiteral_1= ruleNegativeLiteral ) | 2449 | // InternalProblem.g:932:2: (this_Atom_0= ruleAtom | this_NegativeLiteral_1= ruleNegativeLiteral ) |
2448 | { | 2450 | { |
2449 | // InternalProblem.g:923:2: (this_Atom_0= ruleAtom | this_NegativeLiteral_1= ruleNegativeLiteral ) | 2451 | // InternalProblem.g:932:2: (this_Atom_0= ruleAtom | this_NegativeLiteral_1= ruleNegativeLiteral ) |
2450 | int alt25=2; | 2452 | int alt25=2; |
2451 | int LA25_0 = input.LA(1); | 2453 | int LA25_0 = input.LA(1); |
2452 | 2454 | ||
2453 | if ( (LA25_0==RULE_ID||LA25_0==RULE_QUOTED_ID||(LA25_0>=41 && LA25_0<=42)) ) { | 2455 | if ( (LA25_0==RULE_ID||LA25_0==RULE_QUOTED_ID||(LA25_0>=41 && LA25_0<=44)) ) { |
2454 | alt25=1; | 2456 | alt25=1; |
2455 | } | 2457 | } |
2456 | else if ( (LA25_0==32) ) { | 2458 | else if ( (LA25_0==32) ) { |
@@ -2464,7 +2466,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2464 | } | 2466 | } |
2465 | switch (alt25) { | 2467 | switch (alt25) { |
2466 | case 1 : | 2468 | case 1 : |
2467 | // InternalProblem.g:924:3: this_Atom_0= ruleAtom | 2469 | // InternalProblem.g:933:3: this_Atom_0= ruleAtom |
2468 | { | 2470 | { |
2469 | 2471 | ||
2470 | newCompositeNode(grammarAccess.getLiteralAccess().getAtomParserRuleCall_0()); | 2472 | newCompositeNode(grammarAccess.getLiteralAccess().getAtomParserRuleCall_0()); |
@@ -2482,7 +2484,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2482 | } | 2484 | } |
2483 | break; | 2485 | break; |
2484 | case 2 : | 2486 | case 2 : |
2485 | // InternalProblem.g:933:3: this_NegativeLiteral_1= ruleNegativeLiteral | 2487 | // InternalProblem.g:942:3: this_NegativeLiteral_1= ruleNegativeLiteral |
2486 | { | 2488 | { |
2487 | 2489 | ||
2488 | newCompositeNode(grammarAccess.getLiteralAccess().getNegativeLiteralParserRuleCall_1()); | 2490 | newCompositeNode(grammarAccess.getLiteralAccess().getNegativeLiteralParserRuleCall_1()); |
@@ -2522,7 +2524,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2522 | 2524 | ||
2523 | 2525 | ||
2524 | // $ANTLR start "entryRuleNegativeLiteral" | 2526 | // $ANTLR start "entryRuleNegativeLiteral" |
2525 | // InternalProblem.g:945:1: entryRuleNegativeLiteral returns [EObject current=null] : iv_ruleNegativeLiteral= ruleNegativeLiteral EOF ; | 2527 | // InternalProblem.g:954:1: entryRuleNegativeLiteral returns [EObject current=null] : iv_ruleNegativeLiteral= ruleNegativeLiteral EOF ; |
2526 | public final EObject entryRuleNegativeLiteral() throws RecognitionException { | 2528 | public final EObject entryRuleNegativeLiteral() throws RecognitionException { |
2527 | EObject current = null; | 2529 | EObject current = null; |
2528 | 2530 | ||
@@ -2530,8 +2532,8 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2530 | 2532 | ||
2531 | 2533 | ||
2532 | try { | 2534 | try { |
2533 | // InternalProblem.g:945:56: (iv_ruleNegativeLiteral= ruleNegativeLiteral EOF ) | 2535 | // InternalProblem.g:954:56: (iv_ruleNegativeLiteral= ruleNegativeLiteral EOF ) |
2534 | // InternalProblem.g:946:2: iv_ruleNegativeLiteral= ruleNegativeLiteral EOF | 2536 | // InternalProblem.g:955:2: iv_ruleNegativeLiteral= ruleNegativeLiteral EOF |
2535 | { | 2537 | { |
2536 | newCompositeNode(grammarAccess.getNegativeLiteralRule()); | 2538 | newCompositeNode(grammarAccess.getNegativeLiteralRule()); |
2537 | pushFollow(FOLLOW_1); | 2539 | pushFollow(FOLLOW_1); |
@@ -2558,7 +2560,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2558 | 2560 | ||
2559 | 2561 | ||
2560 | // $ANTLR start "ruleNegativeLiteral" | 2562 | // $ANTLR start "ruleNegativeLiteral" |
2561 | // InternalProblem.g:952:1: ruleNegativeLiteral returns [EObject current=null] : (otherlv_0= '!' ( (lv_atom_1_0= ruleAtom ) ) ) ; | 2563 | // InternalProblem.g:961:1: ruleNegativeLiteral returns [EObject current=null] : (otherlv_0= '!' ( (lv_atom_1_0= ruleAtom ) ) ) ; |
2562 | public final EObject ruleNegativeLiteral() throws RecognitionException { | 2564 | public final EObject ruleNegativeLiteral() throws RecognitionException { |
2563 | EObject current = null; | 2565 | EObject current = null; |
2564 | 2566 | ||
@@ -2570,21 +2572,21 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2570 | enterRule(); | 2572 | enterRule(); |
2571 | 2573 | ||
2572 | try { | 2574 | try { |
2573 | // InternalProblem.g:958:2: ( (otherlv_0= '!' ( (lv_atom_1_0= ruleAtom ) ) ) ) | 2575 | // InternalProblem.g:967:2: ( (otherlv_0= '!' ( (lv_atom_1_0= ruleAtom ) ) ) ) |
2574 | // InternalProblem.g:959:2: (otherlv_0= '!' ( (lv_atom_1_0= ruleAtom ) ) ) | 2576 | // InternalProblem.g:968:2: (otherlv_0= '!' ( (lv_atom_1_0= ruleAtom ) ) ) |
2575 | { | 2577 | { |
2576 | // InternalProblem.g:959:2: (otherlv_0= '!' ( (lv_atom_1_0= ruleAtom ) ) ) | 2578 | // InternalProblem.g:968:2: (otherlv_0= '!' ( (lv_atom_1_0= ruleAtom ) ) ) |
2577 | // InternalProblem.g:960:3: otherlv_0= '!' ( (lv_atom_1_0= ruleAtom ) ) | 2579 | // InternalProblem.g:969:3: otherlv_0= '!' ( (lv_atom_1_0= ruleAtom ) ) |
2578 | { | 2580 | { |
2579 | otherlv_0=(Token)match(input,32,FOLLOW_8); | 2581 | otherlv_0=(Token)match(input,32,FOLLOW_8); |
2580 | 2582 | ||
2581 | newLeafNode(otherlv_0, grammarAccess.getNegativeLiteralAccess().getExclamationMarkKeyword_0()); | 2583 | newLeafNode(otherlv_0, grammarAccess.getNegativeLiteralAccess().getExclamationMarkKeyword_0()); |
2582 | 2584 | ||
2583 | // InternalProblem.g:964:3: ( (lv_atom_1_0= ruleAtom ) ) | 2585 | // InternalProblem.g:973:3: ( (lv_atom_1_0= ruleAtom ) ) |
2584 | // InternalProblem.g:965:4: (lv_atom_1_0= ruleAtom ) | 2586 | // InternalProblem.g:974:4: (lv_atom_1_0= ruleAtom ) |
2585 | { | 2587 | { |
2586 | // InternalProblem.g:965:4: (lv_atom_1_0= ruleAtom ) | 2588 | // InternalProblem.g:974:4: (lv_atom_1_0= ruleAtom ) |
2587 | // InternalProblem.g:966:5: lv_atom_1_0= ruleAtom | 2589 | // InternalProblem.g:975:5: lv_atom_1_0= ruleAtom |
2588 | { | 2590 | { |
2589 | 2591 | ||
2590 | newCompositeNode(grammarAccess.getNegativeLiteralAccess().getAtomAtomParserRuleCall_1_0()); | 2592 | newCompositeNode(grammarAccess.getNegativeLiteralAccess().getAtomAtomParserRuleCall_1_0()); |
@@ -2634,7 +2636,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2634 | 2636 | ||
2635 | 2637 | ||
2636 | // $ANTLR start "entryRuleAtom" | 2638 | // $ANTLR start "entryRuleAtom" |
2637 | // InternalProblem.g:987:1: entryRuleAtom returns [EObject current=null] : iv_ruleAtom= ruleAtom EOF ; | 2639 | // InternalProblem.g:996:1: entryRuleAtom returns [EObject current=null] : iv_ruleAtom= ruleAtom EOF ; |
2638 | public final EObject entryRuleAtom() throws RecognitionException { | 2640 | public final EObject entryRuleAtom() throws RecognitionException { |
2639 | EObject current = null; | 2641 | EObject current = null; |
2640 | 2642 | ||
@@ -2642,8 +2644,8 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2642 | 2644 | ||
2643 | 2645 | ||
2644 | try { | 2646 | try { |
2645 | // InternalProblem.g:987:45: (iv_ruleAtom= ruleAtom EOF ) | 2647 | // InternalProblem.g:996:45: (iv_ruleAtom= ruleAtom EOF ) |
2646 | // InternalProblem.g:988:2: iv_ruleAtom= ruleAtom EOF | 2648 | // InternalProblem.g:997:2: iv_ruleAtom= ruleAtom EOF |
2647 | { | 2649 | { |
2648 | newCompositeNode(grammarAccess.getAtomRule()); | 2650 | newCompositeNode(grammarAccess.getAtomRule()); |
2649 | pushFollow(FOLLOW_1); | 2651 | pushFollow(FOLLOW_1); |
@@ -2670,7 +2672,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2670 | 2672 | ||
2671 | 2673 | ||
2672 | // $ANTLR start "ruleAtom" | 2674 | // $ANTLR start "ruleAtom" |
2673 | // InternalProblem.g:994:1: ruleAtom returns [EObject current=null] : ( ( ( ruleQualifiedName ) ) ( (lv_transitiveClosure_1_0= '+' ) )? otherlv_2= '(' ( ( (lv_arguments_3_0= ruleArgument ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) )* )? otherlv_6= ')' ) ; | 2675 | // InternalProblem.g:1003:1: ruleAtom returns [EObject current=null] : ( ( ( ruleQualifiedName ) ) ( (lv_transitiveClosure_1_0= '+' ) )? otherlv_2= '(' ( ( (lv_arguments_3_0= ruleArgument ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) )* )? otherlv_6= ')' ) ; |
2674 | public final EObject ruleAtom() throws RecognitionException { | 2676 | public final EObject ruleAtom() throws RecognitionException { |
2675 | EObject current = null; | 2677 | EObject current = null; |
2676 | 2678 | ||
@@ -2687,17 +2689,17 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2687 | enterRule(); | 2689 | enterRule(); |
2688 | 2690 | ||
2689 | try { | 2691 | try { |
2690 | // InternalProblem.g:1000:2: ( ( ( ( ruleQualifiedName ) ) ( (lv_transitiveClosure_1_0= '+' ) )? otherlv_2= '(' ( ( (lv_arguments_3_0= ruleArgument ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) )* )? otherlv_6= ')' ) ) | 2692 | // InternalProblem.g:1009:2: ( ( ( ( ruleQualifiedName ) ) ( (lv_transitiveClosure_1_0= '+' ) )? otherlv_2= '(' ( ( (lv_arguments_3_0= ruleArgument ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) )* )? otherlv_6= ')' ) ) |
2691 | // InternalProblem.g:1001:2: ( ( ( ruleQualifiedName ) ) ( (lv_transitiveClosure_1_0= '+' ) )? otherlv_2= '(' ( ( (lv_arguments_3_0= ruleArgument ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) )* )? otherlv_6= ')' ) | 2693 | // InternalProblem.g:1010:2: ( ( ( ruleQualifiedName ) ) ( (lv_transitiveClosure_1_0= '+' ) )? otherlv_2= '(' ( ( (lv_arguments_3_0= ruleArgument ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) )* )? otherlv_6= ')' ) |
2692 | { | 2694 | { |
2693 | // InternalProblem.g:1001:2: ( ( ( ruleQualifiedName ) ) ( (lv_transitiveClosure_1_0= '+' ) )? otherlv_2= '(' ( ( (lv_arguments_3_0= ruleArgument ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) )* )? otherlv_6= ')' ) | 2695 | // InternalProblem.g:1010:2: ( ( ( ruleQualifiedName ) ) ( (lv_transitiveClosure_1_0= '+' ) )? otherlv_2= '(' ( ( (lv_arguments_3_0= ruleArgument ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) )* )? otherlv_6= ')' ) |
2694 | // InternalProblem.g:1002:3: ( ( ruleQualifiedName ) ) ( (lv_transitiveClosure_1_0= '+' ) )? otherlv_2= '(' ( ( (lv_arguments_3_0= ruleArgument ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) )* )? otherlv_6= ')' | 2696 | // InternalProblem.g:1011:3: ( ( ruleQualifiedName ) ) ( (lv_transitiveClosure_1_0= '+' ) )? otherlv_2= '(' ( ( (lv_arguments_3_0= ruleArgument ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) )* )? otherlv_6= ')' |
2695 | { | 2697 | { |
2696 | // InternalProblem.g:1002:3: ( ( ruleQualifiedName ) ) | 2698 | // InternalProblem.g:1011:3: ( ( ruleQualifiedName ) ) |
2697 | // InternalProblem.g:1003:4: ( ruleQualifiedName ) | 2699 | // InternalProblem.g:1012:4: ( ruleQualifiedName ) |
2698 | { | 2700 | { |
2699 | // InternalProblem.g:1003:4: ( ruleQualifiedName ) | 2701 | // InternalProblem.g:1012:4: ( ruleQualifiedName ) |
2700 | // InternalProblem.g:1004:5: ruleQualifiedName | 2702 | // InternalProblem.g:1013:5: ruleQualifiedName |
2701 | { | 2703 | { |
2702 | 2704 | ||
2703 | if (current==null) { | 2705 | if (current==null) { |
@@ -2721,7 +2723,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2721 | 2723 | ||
2722 | } | 2724 | } |
2723 | 2725 | ||
2724 | // InternalProblem.g:1018:3: ( (lv_transitiveClosure_1_0= '+' ) )? | 2726 | // InternalProblem.g:1027:3: ( (lv_transitiveClosure_1_0= '+' ) )? |
2725 | int alt26=2; | 2727 | int alt26=2; |
2726 | int LA26_0 = input.LA(1); | 2728 | int LA26_0 = input.LA(1); |
2727 | 2729 | ||
@@ -2730,10 +2732,10 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2730 | } | 2732 | } |
2731 | switch (alt26) { | 2733 | switch (alt26) { |
2732 | case 1 : | 2734 | case 1 : |
2733 | // InternalProblem.g:1019:4: (lv_transitiveClosure_1_0= '+' ) | 2735 | // InternalProblem.g:1028:4: (lv_transitiveClosure_1_0= '+' ) |
2734 | { | 2736 | { |
2735 | // InternalProblem.g:1019:4: (lv_transitiveClosure_1_0= '+' ) | 2737 | // InternalProblem.g:1028:4: (lv_transitiveClosure_1_0= '+' ) |
2736 | // InternalProblem.g:1020:5: lv_transitiveClosure_1_0= '+' | 2738 | // InternalProblem.g:1029:5: lv_transitiveClosure_1_0= '+' |
2737 | { | 2739 | { |
2738 | lv_transitiveClosure_1_0=(Token)match(input,33,FOLLOW_21); | 2740 | lv_transitiveClosure_1_0=(Token)match(input,33,FOLLOW_21); |
2739 | 2741 | ||
@@ -2754,26 +2756,26 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2754 | 2756 | ||
2755 | } | 2757 | } |
2756 | 2758 | ||
2757 | otherlv_2=(Token)match(input,29,FOLLOW_22); | 2759 | otherlv_2=(Token)match(input,29,FOLLOW_29); |
2758 | 2760 | ||
2759 | newLeafNode(otherlv_2, grammarAccess.getAtomAccess().getLeftParenthesisKeyword_2()); | 2761 | newLeafNode(otherlv_2, grammarAccess.getAtomAccess().getLeftParenthesisKeyword_2()); |
2760 | 2762 | ||
2761 | // InternalProblem.g:1036:3: ( ( (lv_arguments_3_0= ruleArgument ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) )* )? | 2763 | // InternalProblem.g:1045:3: ( ( (lv_arguments_3_0= ruleArgument ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) )* )? |
2762 | int alt28=2; | 2764 | int alt28=2; |
2763 | int LA28_0 = input.LA(1); | 2765 | int LA28_0 = input.LA(1); |
2764 | 2766 | ||
2765 | if ( (LA28_0==RULE_ID||LA28_0==RULE_QUOTED_ID||(LA28_0>=41 && LA28_0<=42)) ) { | 2767 | if ( ((LA28_0>=RULE_STRING && LA28_0<=RULE_QUOTED_ID)||(LA28_0>=41 && LA28_0<=45)) ) { |
2766 | alt28=1; | 2768 | alt28=1; |
2767 | } | 2769 | } |
2768 | switch (alt28) { | 2770 | switch (alt28) { |
2769 | case 1 : | 2771 | case 1 : |
2770 | // InternalProblem.g:1037:4: ( (lv_arguments_3_0= ruleArgument ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) )* | 2772 | // InternalProblem.g:1046:4: ( (lv_arguments_3_0= ruleArgument ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) )* |
2771 | { | 2773 | { |
2772 | // InternalProblem.g:1037:4: ( (lv_arguments_3_0= ruleArgument ) ) | 2774 | // InternalProblem.g:1046:4: ( (lv_arguments_3_0= ruleArgument ) ) |
2773 | // InternalProblem.g:1038:5: (lv_arguments_3_0= ruleArgument ) | 2775 | // InternalProblem.g:1047:5: (lv_arguments_3_0= ruleArgument ) |
2774 | { | 2776 | { |
2775 | // InternalProblem.g:1038:5: (lv_arguments_3_0= ruleArgument ) | 2777 | // InternalProblem.g:1047:5: (lv_arguments_3_0= ruleArgument ) |
2776 | // InternalProblem.g:1039:6: lv_arguments_3_0= ruleArgument | 2778 | // InternalProblem.g:1048:6: lv_arguments_3_0= ruleArgument |
2777 | { | 2779 | { |
2778 | 2780 | ||
2779 | newCompositeNode(grammarAccess.getAtomAccess().getArgumentsArgumentParserRuleCall_3_0_0()); | 2781 | newCompositeNode(grammarAccess.getAtomAccess().getArgumentsArgumentParserRuleCall_3_0_0()); |
@@ -2800,7 +2802,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2800 | 2802 | ||
2801 | } | 2803 | } |
2802 | 2804 | ||
2803 | // InternalProblem.g:1056:4: (otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) )* | 2805 | // InternalProblem.g:1065:4: (otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) )* |
2804 | loop27: | 2806 | loop27: |
2805 | do { | 2807 | do { |
2806 | int alt27=2; | 2808 | int alt27=2; |
@@ -2813,17 +2815,17 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2813 | 2815 | ||
2814 | switch (alt27) { | 2816 | switch (alt27) { |
2815 | case 1 : | 2817 | case 1 : |
2816 | // InternalProblem.g:1057:5: otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) | 2818 | // InternalProblem.g:1066:5: otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) |
2817 | { | 2819 | { |
2818 | otherlv_4=(Token)match(input,17,FOLLOW_8); | 2820 | otherlv_4=(Token)match(input,17,FOLLOW_30); |
2819 | 2821 | ||
2820 | newLeafNode(otherlv_4, grammarAccess.getAtomAccess().getCommaKeyword_3_1_0()); | 2822 | newLeafNode(otherlv_4, grammarAccess.getAtomAccess().getCommaKeyword_3_1_0()); |
2821 | 2823 | ||
2822 | // InternalProblem.g:1061:5: ( (lv_arguments_5_0= ruleArgument ) ) | 2824 | // InternalProblem.g:1070:5: ( (lv_arguments_5_0= ruleArgument ) ) |
2823 | // InternalProblem.g:1062:6: (lv_arguments_5_0= ruleArgument ) | 2825 | // InternalProblem.g:1071:6: (lv_arguments_5_0= ruleArgument ) |
2824 | { | 2826 | { |
2825 | // InternalProblem.g:1062:6: (lv_arguments_5_0= ruleArgument ) | 2827 | // InternalProblem.g:1071:6: (lv_arguments_5_0= ruleArgument ) |
2826 | // InternalProblem.g:1063:7: lv_arguments_5_0= ruleArgument | 2828 | // InternalProblem.g:1072:7: lv_arguments_5_0= ruleArgument |
2827 | { | 2829 | { |
2828 | 2830 | ||
2829 | newCompositeNode(grammarAccess.getAtomAccess().getArgumentsArgumentParserRuleCall_3_1_1_0()); | 2831 | newCompositeNode(grammarAccess.getAtomAccess().getArgumentsArgumentParserRuleCall_3_1_1_0()); |
@@ -2892,7 +2894,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2892 | 2894 | ||
2893 | 2895 | ||
2894 | // $ANTLR start "entryRuleArgument" | 2896 | // $ANTLR start "entryRuleArgument" |
2895 | // InternalProblem.g:1090:1: entryRuleArgument returns [EObject current=null] : iv_ruleArgument= ruleArgument EOF ; | 2897 | // InternalProblem.g:1099:1: entryRuleArgument returns [EObject current=null] : iv_ruleArgument= ruleArgument EOF ; |
2896 | public final EObject entryRuleArgument() throws RecognitionException { | 2898 | public final EObject entryRuleArgument() throws RecognitionException { |
2897 | EObject current = null; | 2899 | EObject current = null; |
2898 | 2900 | ||
@@ -2900,8 +2902,8 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2900 | 2902 | ||
2901 | 2903 | ||
2902 | try { | 2904 | try { |
2903 | // InternalProblem.g:1090:49: (iv_ruleArgument= ruleArgument EOF ) | 2905 | // InternalProblem.g:1099:49: (iv_ruleArgument= ruleArgument EOF ) |
2904 | // InternalProblem.g:1091:2: iv_ruleArgument= ruleArgument EOF | 2906 | // InternalProblem.g:1100:2: iv_ruleArgument= ruleArgument EOF |
2905 | { | 2907 | { |
2906 | newCompositeNode(grammarAccess.getArgumentRule()); | 2908 | newCompositeNode(grammarAccess.getArgumentRule()); |
2907 | pushFollow(FOLLOW_1); | 2909 | pushFollow(FOLLOW_1); |
@@ -2928,30 +2930,158 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2928 | 2930 | ||
2929 | 2931 | ||
2930 | // $ANTLR start "ruleArgument" | 2932 | // $ANTLR start "ruleArgument" |
2931 | // InternalProblem.g:1097:1: ruleArgument returns [EObject current=null] : ( ( ruleQualifiedName ) ) ; | 2933 | // InternalProblem.g:1106:1: ruleArgument returns [EObject current=null] : (this_VariableOrNodeArgument_0= ruleVariableOrNodeArgument | this_ConstantArgument_1= ruleConstantArgument ) ; |
2932 | public final EObject ruleArgument() throws RecognitionException { | 2934 | public final EObject ruleArgument() throws RecognitionException { |
2933 | EObject current = null; | 2935 | EObject current = null; |
2934 | 2936 | ||
2937 | EObject this_VariableOrNodeArgument_0 = null; | ||
2938 | |||
2939 | EObject this_ConstantArgument_1 = null; | ||
2940 | |||
2941 | |||
2942 | |||
2943 | enterRule(); | ||
2944 | |||
2945 | try { | ||
2946 | // InternalProblem.g:1112:2: ( (this_VariableOrNodeArgument_0= ruleVariableOrNodeArgument | this_ConstantArgument_1= ruleConstantArgument ) ) | ||
2947 | // InternalProblem.g:1113:2: (this_VariableOrNodeArgument_0= ruleVariableOrNodeArgument | this_ConstantArgument_1= ruleConstantArgument ) | ||
2948 | { | ||
2949 | // InternalProblem.g:1113:2: (this_VariableOrNodeArgument_0= ruleVariableOrNodeArgument | this_ConstantArgument_1= ruleConstantArgument ) | ||
2950 | int alt29=2; | ||
2951 | int LA29_0 = input.LA(1); | ||
2952 | |||
2953 | if ( (LA29_0==RULE_ID||LA29_0==RULE_QUOTED_ID||(LA29_0>=41 && LA29_0<=44)) ) { | ||
2954 | alt29=1; | ||
2955 | } | ||
2956 | else if ( (LA29_0==RULE_STRING||LA29_0==RULE_INT||LA29_0==45) ) { | ||
2957 | alt29=2; | ||
2958 | } | ||
2959 | else { | ||
2960 | NoViableAltException nvae = | ||
2961 | new NoViableAltException("", 29, 0, input); | ||
2962 | |||
2963 | throw nvae; | ||
2964 | } | ||
2965 | switch (alt29) { | ||
2966 | case 1 : | ||
2967 | // InternalProblem.g:1114:3: this_VariableOrNodeArgument_0= ruleVariableOrNodeArgument | ||
2968 | { | ||
2969 | |||
2970 | newCompositeNode(grammarAccess.getArgumentAccess().getVariableOrNodeArgumentParserRuleCall_0()); | ||
2971 | |||
2972 | pushFollow(FOLLOW_2); | ||
2973 | this_VariableOrNodeArgument_0=ruleVariableOrNodeArgument(); | ||
2974 | |||
2975 | state._fsp--; | ||
2976 | |||
2977 | |||
2978 | current = this_VariableOrNodeArgument_0; | ||
2979 | afterParserOrEnumRuleCall(); | ||
2980 | |||
2981 | |||
2982 | } | ||
2983 | break; | ||
2984 | case 2 : | ||
2985 | // InternalProblem.g:1123:3: this_ConstantArgument_1= ruleConstantArgument | ||
2986 | { | ||
2987 | |||
2988 | newCompositeNode(grammarAccess.getArgumentAccess().getConstantArgumentParserRuleCall_1()); | ||
2989 | |||
2990 | pushFollow(FOLLOW_2); | ||
2991 | this_ConstantArgument_1=ruleConstantArgument(); | ||
2992 | |||
2993 | state._fsp--; | ||
2994 | |||
2995 | |||
2996 | current = this_ConstantArgument_1; | ||
2997 | afterParserOrEnumRuleCall(); | ||
2998 | |||
2999 | |||
3000 | } | ||
3001 | break; | ||
3002 | |||
3003 | } | ||
3004 | |||
3005 | |||
3006 | } | ||
3007 | |||
3008 | |||
3009 | leaveRule(); | ||
3010 | |||
3011 | } | ||
3012 | |||
3013 | catch (RecognitionException re) { | ||
3014 | recover(input,re); | ||
3015 | appendSkippedTokens(); | ||
3016 | } | ||
3017 | finally { | ||
3018 | } | ||
3019 | return current; | ||
3020 | } | ||
3021 | // $ANTLR end "ruleArgument" | ||
3022 | |||
3023 | |||
3024 | // $ANTLR start "entryRuleVariableOrNodeArgument" | ||
3025 | // InternalProblem.g:1135:1: entryRuleVariableOrNodeArgument returns [EObject current=null] : iv_ruleVariableOrNodeArgument= ruleVariableOrNodeArgument EOF ; | ||
3026 | public final EObject entryRuleVariableOrNodeArgument() throws RecognitionException { | ||
3027 | EObject current = null; | ||
3028 | |||
3029 | EObject iv_ruleVariableOrNodeArgument = null; | ||
3030 | |||
3031 | |||
3032 | try { | ||
3033 | // InternalProblem.g:1135:63: (iv_ruleVariableOrNodeArgument= ruleVariableOrNodeArgument EOF ) | ||
3034 | // InternalProblem.g:1136:2: iv_ruleVariableOrNodeArgument= ruleVariableOrNodeArgument EOF | ||
3035 | { | ||
3036 | newCompositeNode(grammarAccess.getVariableOrNodeArgumentRule()); | ||
3037 | pushFollow(FOLLOW_1); | ||
3038 | iv_ruleVariableOrNodeArgument=ruleVariableOrNodeArgument(); | ||
3039 | |||
3040 | state._fsp--; | ||
3041 | |||
3042 | current =iv_ruleVariableOrNodeArgument; | ||
3043 | match(input,EOF,FOLLOW_2); | ||
3044 | |||
3045 | } | ||
3046 | |||
3047 | } | ||
3048 | |||
3049 | catch (RecognitionException re) { | ||
3050 | recover(input,re); | ||
3051 | appendSkippedTokens(); | ||
3052 | } | ||
3053 | finally { | ||
3054 | } | ||
3055 | return current; | ||
3056 | } | ||
3057 | // $ANTLR end "entryRuleVariableOrNodeArgument" | ||
3058 | |||
3059 | |||
3060 | // $ANTLR start "ruleVariableOrNodeArgument" | ||
3061 | // InternalProblem.g:1142:1: ruleVariableOrNodeArgument returns [EObject current=null] : ( ( ruleQualifiedName ) ) ; | ||
3062 | public final EObject ruleVariableOrNodeArgument() throws RecognitionException { | ||
3063 | EObject current = null; | ||
3064 | |||
2935 | 3065 | ||
2936 | enterRule(); | 3066 | enterRule(); |
2937 | 3067 | ||
2938 | try { | 3068 | try { |
2939 | // InternalProblem.g:1103:2: ( ( ( ruleQualifiedName ) ) ) | 3069 | // InternalProblem.g:1148:2: ( ( ( ruleQualifiedName ) ) ) |
2940 | // InternalProblem.g:1104:2: ( ( ruleQualifiedName ) ) | 3070 | // InternalProblem.g:1149:2: ( ( ruleQualifiedName ) ) |
2941 | { | 3071 | { |
2942 | // InternalProblem.g:1104:2: ( ( ruleQualifiedName ) ) | 3072 | // InternalProblem.g:1149:2: ( ( ruleQualifiedName ) ) |
2943 | // InternalProblem.g:1105:3: ( ruleQualifiedName ) | 3073 | // InternalProblem.g:1150:3: ( ruleQualifiedName ) |
2944 | { | 3074 | { |
2945 | // InternalProblem.g:1105:3: ( ruleQualifiedName ) | 3075 | // InternalProblem.g:1150:3: ( ruleQualifiedName ) |
2946 | // InternalProblem.g:1106:4: ruleQualifiedName | 3076 | // InternalProblem.g:1151:4: ruleQualifiedName |
2947 | { | 3077 | { |
2948 | 3078 | ||
2949 | if (current==null) { | 3079 | if (current==null) { |
2950 | current = createModelElement(grammarAccess.getArgumentRule()); | 3080 | current = createModelElement(grammarAccess.getVariableOrNodeArgumentRule()); |
2951 | } | 3081 | } |
2952 | 3082 | ||
2953 | 3083 | ||
2954 | newCompositeNode(grammarAccess.getArgumentAccess().getVariableOrNodeVariableOrNodeCrossReference_0()); | 3084 | newCompositeNode(grammarAccess.getVariableOrNodeArgumentAccess().getVariableOrNodeVariableOrNodeCrossReference_0()); |
2955 | 3085 | ||
2956 | pushFollow(FOLLOW_2); | 3086 | pushFollow(FOLLOW_2); |
2957 | ruleQualifiedName(); | 3087 | ruleQualifiedName(); |
@@ -2983,11 +3113,112 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2983 | } | 3113 | } |
2984 | return current; | 3114 | return current; |
2985 | } | 3115 | } |
2986 | // $ANTLR end "ruleArgument" | 3116 | // $ANTLR end "ruleVariableOrNodeArgument" |
3117 | |||
3118 | |||
3119 | // $ANTLR start "entryRuleConstantArgument" | ||
3120 | // InternalProblem.g:1168:1: entryRuleConstantArgument returns [EObject current=null] : iv_ruleConstantArgument= ruleConstantArgument EOF ; | ||
3121 | public final EObject entryRuleConstantArgument() throws RecognitionException { | ||
3122 | EObject current = null; | ||
3123 | |||
3124 | EObject iv_ruleConstantArgument = null; | ||
3125 | |||
3126 | |||
3127 | try { | ||
3128 | // InternalProblem.g:1168:57: (iv_ruleConstantArgument= ruleConstantArgument EOF ) | ||
3129 | // InternalProblem.g:1169:2: iv_ruleConstantArgument= ruleConstantArgument EOF | ||
3130 | { | ||
3131 | newCompositeNode(grammarAccess.getConstantArgumentRule()); | ||
3132 | pushFollow(FOLLOW_1); | ||
3133 | iv_ruleConstantArgument=ruleConstantArgument(); | ||
3134 | |||
3135 | state._fsp--; | ||
3136 | |||
3137 | current =iv_ruleConstantArgument; | ||
3138 | match(input,EOF,FOLLOW_2); | ||
3139 | |||
3140 | } | ||
3141 | |||
3142 | } | ||
3143 | |||
3144 | catch (RecognitionException re) { | ||
3145 | recover(input,re); | ||
3146 | appendSkippedTokens(); | ||
3147 | } | ||
3148 | finally { | ||
3149 | } | ||
3150 | return current; | ||
3151 | } | ||
3152 | // $ANTLR end "entryRuleConstantArgument" | ||
3153 | |||
3154 | |||
3155 | // $ANTLR start "ruleConstantArgument" | ||
3156 | // InternalProblem.g:1175:1: ruleConstantArgument returns [EObject current=null] : ( (lv_constant_0_0= ruleConstant ) ) ; | ||
3157 | public final EObject ruleConstantArgument() throws RecognitionException { | ||
3158 | EObject current = null; | ||
3159 | |||
3160 | EObject lv_constant_0_0 = null; | ||
3161 | |||
3162 | |||
3163 | |||
3164 | enterRule(); | ||
3165 | |||
3166 | try { | ||
3167 | // InternalProblem.g:1181:2: ( ( (lv_constant_0_0= ruleConstant ) ) ) | ||
3168 | // InternalProblem.g:1182:2: ( (lv_constant_0_0= ruleConstant ) ) | ||
3169 | { | ||
3170 | // InternalProblem.g:1182:2: ( (lv_constant_0_0= ruleConstant ) ) | ||
3171 | // InternalProblem.g:1183:3: (lv_constant_0_0= ruleConstant ) | ||
3172 | { | ||
3173 | // InternalProblem.g:1183:3: (lv_constant_0_0= ruleConstant ) | ||
3174 | // InternalProblem.g:1184:4: lv_constant_0_0= ruleConstant | ||
3175 | { | ||
3176 | |||
3177 | newCompositeNode(grammarAccess.getConstantArgumentAccess().getConstantConstantParserRuleCall_0()); | ||
3178 | |||
3179 | pushFollow(FOLLOW_2); | ||
3180 | lv_constant_0_0=ruleConstant(); | ||
3181 | |||
3182 | state._fsp--; | ||
3183 | |||
3184 | |||
3185 | if (current==null) { | ||
3186 | current = createModelElementForParent(grammarAccess.getConstantArgumentRule()); | ||
3187 | } | ||
3188 | set( | ||
3189 | current, | ||
3190 | "constant", | ||
3191 | lv_constant_0_0, | ||
3192 | "org.eclipse.viatra.solver.language.Problem.Constant"); | ||
3193 | afterParserOrEnumRuleCall(); | ||
3194 | |||
3195 | |||
3196 | } | ||
3197 | |||
3198 | |||
3199 | } | ||
3200 | |||
3201 | |||
3202 | } | ||
3203 | |||
3204 | |||
3205 | leaveRule(); | ||
3206 | |||
3207 | } | ||
3208 | |||
3209 | catch (RecognitionException re) { | ||
3210 | recover(input,re); | ||
3211 | appendSkippedTokens(); | ||
3212 | } | ||
3213 | finally { | ||
3214 | } | ||
3215 | return current; | ||
3216 | } | ||
3217 | // $ANTLR end "ruleConstantArgument" | ||
2987 | 3218 | ||
2988 | 3219 | ||
2989 | // $ANTLR start "entryRuleAssertion" | 3220 | // $ANTLR start "entryRuleAssertion" |
2990 | // InternalProblem.g:1123:1: entryRuleAssertion returns [EObject current=null] : iv_ruleAssertion= ruleAssertion EOF ; | 3221 | // InternalProblem.g:1204:1: entryRuleAssertion returns [EObject current=null] : iv_ruleAssertion= ruleAssertion EOF ; |
2991 | public final EObject entryRuleAssertion() throws RecognitionException { | 3222 | public final EObject entryRuleAssertion() throws RecognitionException { |
2992 | EObject current = null; | 3223 | EObject current = null; |
2993 | 3224 | ||
@@ -2995,8 +3226,8 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
2995 | 3226 | ||
2996 | 3227 | ||
2997 | try { | 3228 | try { |
2998 | // InternalProblem.g:1123:50: (iv_ruleAssertion= ruleAssertion EOF ) | 3229 | // InternalProblem.g:1204:50: (iv_ruleAssertion= ruleAssertion EOF ) |
2999 | // InternalProblem.g:1124:2: iv_ruleAssertion= ruleAssertion EOF | 3230 | // InternalProblem.g:1205:2: iv_ruleAssertion= ruleAssertion EOF |
3000 | { | 3231 | { |
3001 | newCompositeNode(grammarAccess.getAssertionRule()); | 3232 | newCompositeNode(grammarAccess.getAssertionRule()); |
3002 | pushFollow(FOLLOW_1); | 3233 | pushFollow(FOLLOW_1); |
@@ -3023,7 +3254,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3023 | 3254 | ||
3024 | 3255 | ||
3025 | // $ANTLR start "ruleAssertion" | 3256 | // $ANTLR start "ruleAssertion" |
3026 | // InternalProblem.g:1130:1: ruleAssertion returns [EObject current=null] : ( ( ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( ( ruleQualifiedName ) ) (otherlv_3= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) | ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( ( ruleQualifiedName ) ) (otherlv_12= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_14= ')' ) ) otherlv_15= '.' ) ; | 3257 | // InternalProblem.g:1211:1: ruleAssertion returns [EObject current=null] : ( ( ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( (lv_arguments_2_0= ruleAssertionArgument ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleAssertionArgument ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) | ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( (lv_arguments_11_0= ruleAssertionArgument ) ) (otherlv_12= ',' ( (lv_arguments_13_0= ruleAssertionArgument ) ) )* )? otherlv_14= ')' ) ) otherlv_15= '.' ) ; |
3027 | public final EObject ruleAssertion() throws RecognitionException { | 3258 | public final EObject ruleAssertion() throws RecognitionException { |
3028 | EObject current = null; | 3259 | EObject current = null; |
3029 | 3260 | ||
@@ -3035,36 +3266,44 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3035 | Token otherlv_12=null; | 3266 | Token otherlv_12=null; |
3036 | Token otherlv_14=null; | 3267 | Token otherlv_14=null; |
3037 | Token otherlv_15=null; | 3268 | Token otherlv_15=null; |
3269 | EObject lv_arguments_2_0 = null; | ||
3270 | |||
3271 | EObject lv_arguments_4_0 = null; | ||
3272 | |||
3038 | Enumerator lv_value_7_0 = null; | 3273 | Enumerator lv_value_7_0 = null; |
3039 | 3274 | ||
3040 | Enumerator lv_value_8_0 = null; | 3275 | Enumerator lv_value_8_0 = null; |
3041 | 3276 | ||
3277 | EObject lv_arguments_11_0 = null; | ||
3278 | |||
3279 | EObject lv_arguments_13_0 = null; | ||
3280 | |||
3042 | 3281 | ||
3043 | 3282 | ||
3044 | enterRule(); | 3283 | enterRule(); |
3045 | 3284 | ||
3046 | try { | 3285 | try { |
3047 | // InternalProblem.g:1136:2: ( ( ( ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( ( ruleQualifiedName ) ) (otherlv_3= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) | ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( ( ruleQualifiedName ) ) (otherlv_12= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_14= ')' ) ) otherlv_15= '.' ) ) | 3286 | // InternalProblem.g:1217:2: ( ( ( ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( (lv_arguments_2_0= ruleAssertionArgument ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleAssertionArgument ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) | ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( (lv_arguments_11_0= ruleAssertionArgument ) ) (otherlv_12= ',' ( (lv_arguments_13_0= ruleAssertionArgument ) ) )* )? otherlv_14= ')' ) ) otherlv_15= '.' ) ) |
3048 | // InternalProblem.g:1137:2: ( ( ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( ( ruleQualifiedName ) ) (otherlv_3= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) | ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( ( ruleQualifiedName ) ) (otherlv_12= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_14= ')' ) ) otherlv_15= '.' ) | 3287 | // InternalProblem.g:1218:2: ( ( ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( (lv_arguments_2_0= ruleAssertionArgument ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleAssertionArgument ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) | ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( (lv_arguments_11_0= ruleAssertionArgument ) ) (otherlv_12= ',' ( (lv_arguments_13_0= ruleAssertionArgument ) ) )* )? otherlv_14= ')' ) ) otherlv_15= '.' ) |
3049 | { | 3288 | { |
3050 | // InternalProblem.g:1137:2: ( ( ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( ( ruleQualifiedName ) ) (otherlv_3= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) | ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( ( ruleQualifiedName ) ) (otherlv_12= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_14= ')' ) ) otherlv_15= '.' ) | 3289 | // InternalProblem.g:1218:2: ( ( ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( (lv_arguments_2_0= ruleAssertionArgument ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleAssertionArgument ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) | ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( (lv_arguments_11_0= ruleAssertionArgument ) ) (otherlv_12= ',' ( (lv_arguments_13_0= ruleAssertionArgument ) ) )* )? otherlv_14= ')' ) ) otherlv_15= '.' ) |
3051 | // InternalProblem.g:1138:3: ( ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( ( ruleQualifiedName ) ) (otherlv_3= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) | ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( ( ruleQualifiedName ) ) (otherlv_12= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_14= ')' ) ) otherlv_15= '.' | 3290 | // InternalProblem.g:1219:3: ( ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( (lv_arguments_2_0= ruleAssertionArgument ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleAssertionArgument ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) | ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( (lv_arguments_11_0= ruleAssertionArgument ) ) (otherlv_12= ',' ( (lv_arguments_13_0= ruleAssertionArgument ) ) )* )? otherlv_14= ')' ) ) otherlv_15= '.' |
3052 | { | 3291 | { |
3053 | // InternalProblem.g:1138:3: ( ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( ( ruleQualifiedName ) ) (otherlv_3= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) | ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( ( ruleQualifiedName ) ) (otherlv_12= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_14= ')' ) ) | 3292 | // InternalProblem.g:1219:3: ( ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( (lv_arguments_2_0= ruleAssertionArgument ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleAssertionArgument ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) | ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( (lv_arguments_11_0= ruleAssertionArgument ) ) (otherlv_12= ',' ( (lv_arguments_13_0= ruleAssertionArgument ) ) )* )? otherlv_14= ')' ) ) |
3054 | int alt34=2; | 3293 | int alt35=2; |
3055 | alt34 = dfa34.predict(input); | 3294 | alt35 = dfa35.predict(input); |
3056 | switch (alt34) { | 3295 | switch (alt35) { |
3057 | case 1 : | 3296 | case 1 : |
3058 | // InternalProblem.g:1139:4: ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( ( ruleQualifiedName ) ) (otherlv_3= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) | 3297 | // InternalProblem.g:1220:4: ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( (lv_arguments_2_0= ruleAssertionArgument ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleAssertionArgument ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) |
3059 | { | 3298 | { |
3060 | // InternalProblem.g:1139:4: ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( ( ruleQualifiedName ) ) (otherlv_3= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) | 3299 | // InternalProblem.g:1220:4: ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( (lv_arguments_2_0= ruleAssertionArgument ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleAssertionArgument ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) |
3061 | // InternalProblem.g:1140:5: ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( ( ruleQualifiedName ) ) (otherlv_3= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) | 3300 | // InternalProblem.g:1221:5: ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( (lv_arguments_2_0= ruleAssertionArgument ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleAssertionArgument ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) |
3062 | { | 3301 | { |
3063 | // InternalProblem.g:1140:5: ( ( ruleQualifiedName ) ) | 3302 | // InternalProblem.g:1221:5: ( ( ruleQualifiedName ) ) |
3064 | // InternalProblem.g:1141:6: ( ruleQualifiedName ) | 3303 | // InternalProblem.g:1222:6: ( ruleQualifiedName ) |
3065 | { | 3304 | { |
3066 | // InternalProblem.g:1141:6: ( ruleQualifiedName ) | 3305 | // InternalProblem.g:1222:6: ( ruleQualifiedName ) |
3067 | // InternalProblem.g:1142:7: ruleQualifiedName | 3306 | // InternalProblem.g:1223:7: ruleQualifiedName |
3068 | { | 3307 | { |
3069 | 3308 | ||
3070 | if (current==null) { | 3309 | if (current==null) { |
@@ -3088,41 +3327,44 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3088 | 3327 | ||
3089 | } | 3328 | } |
3090 | 3329 | ||
3091 | otherlv_1=(Token)match(input,29,FOLLOW_22); | 3330 | otherlv_1=(Token)match(input,29,FOLLOW_29); |
3092 | 3331 | ||
3093 | newLeafNode(otherlv_1, grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_0_1()); | 3332 | newLeafNode(otherlv_1, grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_0_1()); |
3094 | 3333 | ||
3095 | // InternalProblem.g:1160:5: ( ( ( ruleQualifiedName ) ) (otherlv_3= ',' ( ( ruleQualifiedName ) ) )* )? | 3334 | // InternalProblem.g:1241:5: ( ( (lv_arguments_2_0= ruleAssertionArgument ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleAssertionArgument ) ) )* )? |
3096 | int alt30=2; | 3335 | int alt31=2; |
3097 | int LA30_0 = input.LA(1); | 3336 | int LA31_0 = input.LA(1); |
3098 | 3337 | ||
3099 | if ( (LA30_0==RULE_ID||LA30_0==RULE_QUOTED_ID||(LA30_0>=41 && LA30_0<=42)) ) { | 3338 | if ( ((LA31_0>=RULE_STRING && LA31_0<=RULE_QUOTED_ID)||(LA31_0>=41 && LA31_0<=45)) ) { |
3100 | alt30=1; | 3339 | alt31=1; |
3101 | } | 3340 | } |
3102 | switch (alt30) { | 3341 | switch (alt31) { |
3103 | case 1 : | 3342 | case 1 : |
3104 | // InternalProblem.g:1161:6: ( ( ruleQualifiedName ) ) (otherlv_3= ',' ( ( ruleQualifiedName ) ) )* | 3343 | // InternalProblem.g:1242:6: ( (lv_arguments_2_0= ruleAssertionArgument ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleAssertionArgument ) ) )* |
3105 | { | 3344 | { |
3106 | // InternalProblem.g:1161:6: ( ( ruleQualifiedName ) ) | 3345 | // InternalProblem.g:1242:6: ( (lv_arguments_2_0= ruleAssertionArgument ) ) |
3107 | // InternalProblem.g:1162:7: ( ruleQualifiedName ) | 3346 | // InternalProblem.g:1243:7: (lv_arguments_2_0= ruleAssertionArgument ) |
3108 | { | 3347 | { |
3109 | // InternalProblem.g:1162:7: ( ruleQualifiedName ) | 3348 | // InternalProblem.g:1243:7: (lv_arguments_2_0= ruleAssertionArgument ) |
3110 | // InternalProblem.g:1163:8: ruleQualifiedName | 3349 | // InternalProblem.g:1244:8: lv_arguments_2_0= ruleAssertionArgument |
3111 | { | 3350 | { |
3112 | 3351 | ||
3113 | if (current==null) { | 3352 | newCompositeNode(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_0_2_0_0()); |
3114 | current = createModelElement(grammarAccess.getAssertionRule()); | ||
3115 | } | ||
3116 | |||
3117 | |||
3118 | newCompositeNode(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_0_2_0_0()); | ||
3119 | 3353 | ||
3120 | pushFollow(FOLLOW_23); | 3354 | pushFollow(FOLLOW_23); |
3121 | ruleQualifiedName(); | 3355 | lv_arguments_2_0=ruleAssertionArgument(); |
3122 | 3356 | ||
3123 | state._fsp--; | 3357 | state._fsp--; |
3124 | 3358 | ||
3125 | 3359 | ||
3360 | if (current==null) { | ||
3361 | current = createModelElementForParent(grammarAccess.getAssertionRule()); | ||
3362 | } | ||
3363 | add( | ||
3364 | current, | ||
3365 | "arguments", | ||
3366 | lv_arguments_2_0, | ||
3367 | "org.eclipse.viatra.solver.language.Problem.AssertionArgument"); | ||
3126 | afterParserOrEnumRuleCall(); | 3368 | afterParserOrEnumRuleCall(); |
3127 | 3369 | ||
3128 | 3370 | ||
@@ -3131,45 +3373,48 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3131 | 3373 | ||
3132 | } | 3374 | } |
3133 | 3375 | ||
3134 | // InternalProblem.g:1177:6: (otherlv_3= ',' ( ( ruleQualifiedName ) ) )* | 3376 | // InternalProblem.g:1261:6: (otherlv_3= ',' ( (lv_arguments_4_0= ruleAssertionArgument ) ) )* |
3135 | loop29: | 3377 | loop30: |
3136 | do { | 3378 | do { |
3137 | int alt29=2; | 3379 | int alt30=2; |
3138 | int LA29_0 = input.LA(1); | 3380 | int LA30_0 = input.LA(1); |
3139 | 3381 | ||
3140 | if ( (LA29_0==17) ) { | 3382 | if ( (LA30_0==17) ) { |
3141 | alt29=1; | 3383 | alt30=1; |
3142 | } | 3384 | } |
3143 | 3385 | ||
3144 | 3386 | ||
3145 | switch (alt29) { | 3387 | switch (alt30) { |
3146 | case 1 : | 3388 | case 1 : |
3147 | // InternalProblem.g:1178:7: otherlv_3= ',' ( ( ruleQualifiedName ) ) | 3389 | // InternalProblem.g:1262:7: otherlv_3= ',' ( (lv_arguments_4_0= ruleAssertionArgument ) ) |
3148 | { | 3390 | { |
3149 | otherlv_3=(Token)match(input,17,FOLLOW_8); | 3391 | otherlv_3=(Token)match(input,17,FOLLOW_30); |
3150 | 3392 | ||
3151 | newLeafNode(otherlv_3, grammarAccess.getAssertionAccess().getCommaKeyword_0_0_2_1_0()); | 3393 | newLeafNode(otherlv_3, grammarAccess.getAssertionAccess().getCommaKeyword_0_0_2_1_0()); |
3152 | 3394 | ||
3153 | // InternalProblem.g:1182:7: ( ( ruleQualifiedName ) ) | 3395 | // InternalProblem.g:1266:7: ( (lv_arguments_4_0= ruleAssertionArgument ) ) |
3154 | // InternalProblem.g:1183:8: ( ruleQualifiedName ) | 3396 | // InternalProblem.g:1267:8: (lv_arguments_4_0= ruleAssertionArgument ) |
3155 | { | 3397 | { |
3156 | // InternalProblem.g:1183:8: ( ruleQualifiedName ) | 3398 | // InternalProblem.g:1267:8: (lv_arguments_4_0= ruleAssertionArgument ) |
3157 | // InternalProblem.g:1184:9: ruleQualifiedName | 3399 | // InternalProblem.g:1268:9: lv_arguments_4_0= ruleAssertionArgument |
3158 | { | 3400 | { |
3159 | 3401 | ||
3160 | if (current==null) { | 3402 | newCompositeNode(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_0_2_1_1_0()); |
3161 | current = createModelElement(grammarAccess.getAssertionRule()); | ||
3162 | } | ||
3163 | |||
3164 | |||
3165 | newCompositeNode(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_0_2_1_1_0()); | ||
3166 | 3403 | ||
3167 | pushFollow(FOLLOW_23); | 3404 | pushFollow(FOLLOW_23); |
3168 | ruleQualifiedName(); | 3405 | lv_arguments_4_0=ruleAssertionArgument(); |
3169 | 3406 | ||
3170 | state._fsp--; | 3407 | state._fsp--; |
3171 | 3408 | ||
3172 | 3409 | ||
3410 | if (current==null) { | ||
3411 | current = createModelElementForParent(grammarAccess.getAssertionRule()); | ||
3412 | } | ||
3413 | add( | ||
3414 | current, | ||
3415 | "arguments", | ||
3416 | lv_arguments_4_0, | ||
3417 | "org.eclipse.viatra.solver.language.Problem.AssertionArgument"); | ||
3173 | afterParserOrEnumRuleCall(); | 3418 | afterParserOrEnumRuleCall(); |
3174 | 3419 | ||
3175 | 3420 | ||
@@ -3183,7 +3428,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3183 | break; | 3428 | break; |
3184 | 3429 | ||
3185 | default : | 3430 | default : |
3186 | break loop29; | 3431 | break loop30; |
3187 | } | 3432 | } |
3188 | } while (true); | 3433 | } while (true); |
3189 | 3434 | ||
@@ -3193,19 +3438,19 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3193 | 3438 | ||
3194 | } | 3439 | } |
3195 | 3440 | ||
3196 | otherlv_5=(Token)match(input,30,FOLLOW_29); | 3441 | otherlv_5=(Token)match(input,30,FOLLOW_31); |
3197 | 3442 | ||
3198 | newLeafNode(otherlv_5, grammarAccess.getAssertionAccess().getRightParenthesisKeyword_0_0_3()); | 3443 | newLeafNode(otherlv_5, grammarAccess.getAssertionAccess().getRightParenthesisKeyword_0_0_3()); |
3199 | 3444 | ||
3200 | otherlv_6=(Token)match(input,34,FOLLOW_30); | 3445 | otherlv_6=(Token)match(input,34,FOLLOW_32); |
3201 | 3446 | ||
3202 | newLeafNode(otherlv_6, grammarAccess.getAssertionAccess().getColonKeyword_0_0_4()); | 3447 | newLeafNode(otherlv_6, grammarAccess.getAssertionAccess().getColonKeyword_0_0_4()); |
3203 | 3448 | ||
3204 | // InternalProblem.g:1208:5: ( (lv_value_7_0= ruleLogicValue ) ) | 3449 | // InternalProblem.g:1295:5: ( (lv_value_7_0= ruleLogicValue ) ) |
3205 | // InternalProblem.g:1209:6: (lv_value_7_0= ruleLogicValue ) | 3450 | // InternalProblem.g:1296:6: (lv_value_7_0= ruleLogicValue ) |
3206 | { | 3451 | { |
3207 | // InternalProblem.g:1209:6: (lv_value_7_0= ruleLogicValue ) | 3452 | // InternalProblem.g:1296:6: (lv_value_7_0= ruleLogicValue ) |
3208 | // InternalProblem.g:1210:7: lv_value_7_0= ruleLogicValue | 3453 | // InternalProblem.g:1297:7: lv_value_7_0= ruleLogicValue |
3209 | { | 3454 | { |
3210 | 3455 | ||
3211 | newCompositeNode(grammarAccess.getAssertionAccess().getValueLogicValueEnumRuleCall_0_0_5_0()); | 3456 | newCompositeNode(grammarAccess.getAssertionAccess().getValueLogicValueEnumRuleCall_0_0_5_0()); |
@@ -3239,24 +3484,24 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3239 | } | 3484 | } |
3240 | break; | 3485 | break; |
3241 | case 2 : | 3486 | case 2 : |
3242 | // InternalProblem.g:1229:4: ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( ( ruleQualifiedName ) ) (otherlv_12= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_14= ')' ) | 3487 | // InternalProblem.g:1316:4: ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( (lv_arguments_11_0= ruleAssertionArgument ) ) (otherlv_12= ',' ( (lv_arguments_13_0= ruleAssertionArgument ) ) )* )? otherlv_14= ')' ) |
3243 | { | 3488 | { |
3244 | // InternalProblem.g:1229:4: ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( ( ruleQualifiedName ) ) (otherlv_12= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_14= ')' ) | 3489 | // InternalProblem.g:1316:4: ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( (lv_arguments_11_0= ruleAssertionArgument ) ) (otherlv_12= ',' ( (lv_arguments_13_0= ruleAssertionArgument ) ) )* )? otherlv_14= ')' ) |
3245 | // InternalProblem.g:1230:5: ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( ( ruleQualifiedName ) ) (otherlv_12= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_14= ')' | 3490 | // InternalProblem.g:1317:5: ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( (lv_arguments_11_0= ruleAssertionArgument ) ) (otherlv_12= ',' ( (lv_arguments_13_0= ruleAssertionArgument ) ) )* )? otherlv_14= ')' |
3246 | { | 3491 | { |
3247 | // InternalProblem.g:1230:5: ( (lv_value_8_0= ruleShortLogicValue ) )? | 3492 | // InternalProblem.g:1317:5: ( (lv_value_8_0= ruleShortLogicValue ) )? |
3248 | int alt31=2; | 3493 | int alt32=2; |
3249 | int LA31_0 = input.LA(1); | 3494 | int LA32_0 = input.LA(1); |
3250 | 3495 | ||
3251 | if ( (LA31_0==32||LA31_0==44) ) { | 3496 | if ( (LA32_0==32||LA32_0==47) ) { |
3252 | alt31=1; | 3497 | alt32=1; |
3253 | } | 3498 | } |
3254 | switch (alt31) { | 3499 | switch (alt32) { |
3255 | case 1 : | 3500 | case 1 : |
3256 | // InternalProblem.g:1231:6: (lv_value_8_0= ruleShortLogicValue ) | 3501 | // InternalProblem.g:1318:6: (lv_value_8_0= ruleShortLogicValue ) |
3257 | { | 3502 | { |
3258 | // InternalProblem.g:1231:6: (lv_value_8_0= ruleShortLogicValue ) | 3503 | // InternalProblem.g:1318:6: (lv_value_8_0= ruleShortLogicValue ) |
3259 | // InternalProblem.g:1232:7: lv_value_8_0= ruleShortLogicValue | 3504 | // InternalProblem.g:1319:7: lv_value_8_0= ruleShortLogicValue |
3260 | { | 3505 | { |
3261 | 3506 | ||
3262 | newCompositeNode(grammarAccess.getAssertionAccess().getValueShortLogicValueEnumRuleCall_0_1_0_0()); | 3507 | newCompositeNode(grammarAccess.getAssertionAccess().getValueShortLogicValueEnumRuleCall_0_1_0_0()); |
@@ -3286,11 +3531,11 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3286 | 3531 | ||
3287 | } | 3532 | } |
3288 | 3533 | ||
3289 | // InternalProblem.g:1249:5: ( ( ruleQualifiedName ) ) | 3534 | // InternalProblem.g:1336:5: ( ( ruleQualifiedName ) ) |
3290 | // InternalProblem.g:1250:6: ( ruleQualifiedName ) | 3535 | // InternalProblem.g:1337:6: ( ruleQualifiedName ) |
3291 | { | 3536 | { |
3292 | // InternalProblem.g:1250:6: ( ruleQualifiedName ) | 3537 | // InternalProblem.g:1337:6: ( ruleQualifiedName ) |
3293 | // InternalProblem.g:1251:7: ruleQualifiedName | 3538 | // InternalProblem.g:1338:7: ruleQualifiedName |
3294 | { | 3539 | { |
3295 | 3540 | ||
3296 | if (current==null) { | 3541 | if (current==null) { |
@@ -3314,41 +3559,44 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3314 | 3559 | ||
3315 | } | 3560 | } |
3316 | 3561 | ||
3317 | otherlv_10=(Token)match(input,29,FOLLOW_22); | 3562 | otherlv_10=(Token)match(input,29,FOLLOW_29); |
3318 | 3563 | ||
3319 | newLeafNode(otherlv_10, grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_1_2()); | 3564 | newLeafNode(otherlv_10, grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_1_2()); |
3320 | 3565 | ||
3321 | // InternalProblem.g:1269:5: ( ( ( ruleQualifiedName ) ) (otherlv_12= ',' ( ( ruleQualifiedName ) ) )* )? | 3566 | // InternalProblem.g:1356:5: ( ( (lv_arguments_11_0= ruleAssertionArgument ) ) (otherlv_12= ',' ( (lv_arguments_13_0= ruleAssertionArgument ) ) )* )? |
3322 | int alt33=2; | 3567 | int alt34=2; |
3323 | int LA33_0 = input.LA(1); | 3568 | int LA34_0 = input.LA(1); |
3324 | 3569 | ||
3325 | if ( (LA33_0==RULE_ID||LA33_0==RULE_QUOTED_ID||(LA33_0>=41 && LA33_0<=42)) ) { | 3570 | if ( ((LA34_0>=RULE_STRING && LA34_0<=RULE_QUOTED_ID)||(LA34_0>=41 && LA34_0<=45)) ) { |
3326 | alt33=1; | 3571 | alt34=1; |
3327 | } | 3572 | } |
3328 | switch (alt33) { | 3573 | switch (alt34) { |
3329 | case 1 : | 3574 | case 1 : |
3330 | // InternalProblem.g:1270:6: ( ( ruleQualifiedName ) ) (otherlv_12= ',' ( ( ruleQualifiedName ) ) )* | 3575 | // InternalProblem.g:1357:6: ( (lv_arguments_11_0= ruleAssertionArgument ) ) (otherlv_12= ',' ( (lv_arguments_13_0= ruleAssertionArgument ) ) )* |
3331 | { | 3576 | { |
3332 | // InternalProblem.g:1270:6: ( ( ruleQualifiedName ) ) | 3577 | // InternalProblem.g:1357:6: ( (lv_arguments_11_0= ruleAssertionArgument ) ) |
3333 | // InternalProblem.g:1271:7: ( ruleQualifiedName ) | 3578 | // InternalProblem.g:1358:7: (lv_arguments_11_0= ruleAssertionArgument ) |
3334 | { | 3579 | { |
3335 | // InternalProblem.g:1271:7: ( ruleQualifiedName ) | 3580 | // InternalProblem.g:1358:7: (lv_arguments_11_0= ruleAssertionArgument ) |
3336 | // InternalProblem.g:1272:8: ruleQualifiedName | 3581 | // InternalProblem.g:1359:8: lv_arguments_11_0= ruleAssertionArgument |
3337 | { | 3582 | { |
3338 | 3583 | ||
3339 | if (current==null) { | 3584 | newCompositeNode(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_1_3_0_0()); |
3340 | current = createModelElement(grammarAccess.getAssertionRule()); | ||
3341 | } | ||
3342 | |||
3343 | |||
3344 | newCompositeNode(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_1_3_0_0()); | ||
3345 | 3585 | ||
3346 | pushFollow(FOLLOW_23); | 3586 | pushFollow(FOLLOW_23); |
3347 | ruleQualifiedName(); | 3587 | lv_arguments_11_0=ruleAssertionArgument(); |
3348 | 3588 | ||
3349 | state._fsp--; | 3589 | state._fsp--; |
3350 | 3590 | ||
3351 | 3591 | ||
3592 | if (current==null) { | ||
3593 | current = createModelElementForParent(grammarAccess.getAssertionRule()); | ||
3594 | } | ||
3595 | add( | ||
3596 | current, | ||
3597 | "arguments", | ||
3598 | lv_arguments_11_0, | ||
3599 | "org.eclipse.viatra.solver.language.Problem.AssertionArgument"); | ||
3352 | afterParserOrEnumRuleCall(); | 3600 | afterParserOrEnumRuleCall(); |
3353 | 3601 | ||
3354 | 3602 | ||
@@ -3357,45 +3605,48 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3357 | 3605 | ||
3358 | } | 3606 | } |
3359 | 3607 | ||
3360 | // InternalProblem.g:1286:6: (otherlv_12= ',' ( ( ruleQualifiedName ) ) )* | 3608 | // InternalProblem.g:1376:6: (otherlv_12= ',' ( (lv_arguments_13_0= ruleAssertionArgument ) ) )* |
3361 | loop32: | 3609 | loop33: |
3362 | do { | 3610 | do { |
3363 | int alt32=2; | 3611 | int alt33=2; |
3364 | int LA32_0 = input.LA(1); | 3612 | int LA33_0 = input.LA(1); |
3365 | 3613 | ||
3366 | if ( (LA32_0==17) ) { | 3614 | if ( (LA33_0==17) ) { |
3367 | alt32=1; | 3615 | alt33=1; |
3368 | } | 3616 | } |
3369 | 3617 | ||
3370 | 3618 | ||
3371 | switch (alt32) { | 3619 | switch (alt33) { |
3372 | case 1 : | 3620 | case 1 : |
3373 | // InternalProblem.g:1287:7: otherlv_12= ',' ( ( ruleQualifiedName ) ) | 3621 | // InternalProblem.g:1377:7: otherlv_12= ',' ( (lv_arguments_13_0= ruleAssertionArgument ) ) |
3374 | { | 3622 | { |
3375 | otherlv_12=(Token)match(input,17,FOLLOW_8); | 3623 | otherlv_12=(Token)match(input,17,FOLLOW_30); |
3376 | 3624 | ||
3377 | newLeafNode(otherlv_12, grammarAccess.getAssertionAccess().getCommaKeyword_0_1_3_1_0()); | 3625 | newLeafNode(otherlv_12, grammarAccess.getAssertionAccess().getCommaKeyword_0_1_3_1_0()); |
3378 | 3626 | ||
3379 | // InternalProblem.g:1291:7: ( ( ruleQualifiedName ) ) | 3627 | // InternalProblem.g:1381:7: ( (lv_arguments_13_0= ruleAssertionArgument ) ) |
3380 | // InternalProblem.g:1292:8: ( ruleQualifiedName ) | 3628 | // InternalProblem.g:1382:8: (lv_arguments_13_0= ruleAssertionArgument ) |
3381 | { | 3629 | { |
3382 | // InternalProblem.g:1292:8: ( ruleQualifiedName ) | 3630 | // InternalProblem.g:1382:8: (lv_arguments_13_0= ruleAssertionArgument ) |
3383 | // InternalProblem.g:1293:9: ruleQualifiedName | 3631 | // InternalProblem.g:1383:9: lv_arguments_13_0= ruleAssertionArgument |
3384 | { | 3632 | { |
3385 | 3633 | ||
3386 | if (current==null) { | 3634 | newCompositeNode(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_1_3_1_1_0()); |
3387 | current = createModelElement(grammarAccess.getAssertionRule()); | ||
3388 | } | ||
3389 | |||
3390 | |||
3391 | newCompositeNode(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_1_3_1_1_0()); | ||
3392 | 3635 | ||
3393 | pushFollow(FOLLOW_23); | 3636 | pushFollow(FOLLOW_23); |
3394 | ruleQualifiedName(); | 3637 | lv_arguments_13_0=ruleAssertionArgument(); |
3395 | 3638 | ||
3396 | state._fsp--; | 3639 | state._fsp--; |
3397 | 3640 | ||
3398 | 3641 | ||
3642 | if (current==null) { | ||
3643 | current = createModelElementForParent(grammarAccess.getAssertionRule()); | ||
3644 | } | ||
3645 | add( | ||
3646 | current, | ||
3647 | "arguments", | ||
3648 | lv_arguments_13_0, | ||
3649 | "org.eclipse.viatra.solver.language.Problem.AssertionArgument"); | ||
3399 | afterParserOrEnumRuleCall(); | 3650 | afterParserOrEnumRuleCall(); |
3400 | 3651 | ||
3401 | 3652 | ||
@@ -3409,7 +3660,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3409 | break; | 3660 | break; |
3410 | 3661 | ||
3411 | default : | 3662 | default : |
3412 | break loop32; | 3663 | break loop33; |
3413 | } | 3664 | } |
3414 | } while (true); | 3665 | } while (true); |
3415 | 3666 | ||
@@ -3458,8 +3709,1017 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3458 | // $ANTLR end "ruleAssertion" | 3709 | // $ANTLR end "ruleAssertion" |
3459 | 3710 | ||
3460 | 3711 | ||
3712 | // $ANTLR start "entryRuleAssertionArgument" | ||
3713 | // InternalProblem.g:1416:1: entryRuleAssertionArgument returns [EObject current=null] : iv_ruleAssertionArgument= ruleAssertionArgument EOF ; | ||
3714 | public final EObject entryRuleAssertionArgument() throws RecognitionException { | ||
3715 | EObject current = null; | ||
3716 | |||
3717 | EObject iv_ruleAssertionArgument = null; | ||
3718 | |||
3719 | |||
3720 | try { | ||
3721 | // InternalProblem.g:1416:58: (iv_ruleAssertionArgument= ruleAssertionArgument EOF ) | ||
3722 | // InternalProblem.g:1417:2: iv_ruleAssertionArgument= ruleAssertionArgument EOF | ||
3723 | { | ||
3724 | newCompositeNode(grammarAccess.getAssertionArgumentRule()); | ||
3725 | pushFollow(FOLLOW_1); | ||
3726 | iv_ruleAssertionArgument=ruleAssertionArgument(); | ||
3727 | |||
3728 | state._fsp--; | ||
3729 | |||
3730 | current =iv_ruleAssertionArgument; | ||
3731 | match(input,EOF,FOLLOW_2); | ||
3732 | |||
3733 | } | ||
3734 | |||
3735 | } | ||
3736 | |||
3737 | catch (RecognitionException re) { | ||
3738 | recover(input,re); | ||
3739 | appendSkippedTokens(); | ||
3740 | } | ||
3741 | finally { | ||
3742 | } | ||
3743 | return current; | ||
3744 | } | ||
3745 | // $ANTLR end "entryRuleAssertionArgument" | ||
3746 | |||
3747 | |||
3748 | // $ANTLR start "ruleAssertionArgument" | ||
3749 | // InternalProblem.g:1423:1: ruleAssertionArgument returns [EObject current=null] : (this_NodeAssertionArgument_0= ruleNodeAssertionArgument | this_ConstantAssertionArgument_1= ruleConstantAssertionArgument ) ; | ||
3750 | public final EObject ruleAssertionArgument() throws RecognitionException { | ||
3751 | EObject current = null; | ||
3752 | |||
3753 | EObject this_NodeAssertionArgument_0 = null; | ||
3754 | |||
3755 | EObject this_ConstantAssertionArgument_1 = null; | ||
3756 | |||
3757 | |||
3758 | |||
3759 | enterRule(); | ||
3760 | |||
3761 | try { | ||
3762 | // InternalProblem.g:1429:2: ( (this_NodeAssertionArgument_0= ruleNodeAssertionArgument | this_ConstantAssertionArgument_1= ruleConstantAssertionArgument ) ) | ||
3763 | // InternalProblem.g:1430:2: (this_NodeAssertionArgument_0= ruleNodeAssertionArgument | this_ConstantAssertionArgument_1= ruleConstantAssertionArgument ) | ||
3764 | { | ||
3765 | // InternalProblem.g:1430:2: (this_NodeAssertionArgument_0= ruleNodeAssertionArgument | this_ConstantAssertionArgument_1= ruleConstantAssertionArgument ) | ||
3766 | int alt36=2; | ||
3767 | int LA36_0 = input.LA(1); | ||
3768 | |||
3769 | if ( (LA36_0==RULE_ID||LA36_0==RULE_QUOTED_ID||(LA36_0>=41 && LA36_0<=44)) ) { | ||
3770 | alt36=1; | ||
3771 | } | ||
3772 | else if ( (LA36_0==RULE_STRING||LA36_0==RULE_INT||LA36_0==45) ) { | ||
3773 | alt36=2; | ||
3774 | } | ||
3775 | else { | ||
3776 | NoViableAltException nvae = | ||
3777 | new NoViableAltException("", 36, 0, input); | ||
3778 | |||
3779 | throw nvae; | ||
3780 | } | ||
3781 | switch (alt36) { | ||
3782 | case 1 : | ||
3783 | // InternalProblem.g:1431:3: this_NodeAssertionArgument_0= ruleNodeAssertionArgument | ||
3784 | { | ||
3785 | |||
3786 | newCompositeNode(grammarAccess.getAssertionArgumentAccess().getNodeAssertionArgumentParserRuleCall_0()); | ||
3787 | |||
3788 | pushFollow(FOLLOW_2); | ||
3789 | this_NodeAssertionArgument_0=ruleNodeAssertionArgument(); | ||
3790 | |||
3791 | state._fsp--; | ||
3792 | |||
3793 | |||
3794 | current = this_NodeAssertionArgument_0; | ||
3795 | afterParserOrEnumRuleCall(); | ||
3796 | |||
3797 | |||
3798 | } | ||
3799 | break; | ||
3800 | case 2 : | ||
3801 | // InternalProblem.g:1440:3: this_ConstantAssertionArgument_1= ruleConstantAssertionArgument | ||
3802 | { | ||
3803 | |||
3804 | newCompositeNode(grammarAccess.getAssertionArgumentAccess().getConstantAssertionArgumentParserRuleCall_1()); | ||
3805 | |||
3806 | pushFollow(FOLLOW_2); | ||
3807 | this_ConstantAssertionArgument_1=ruleConstantAssertionArgument(); | ||
3808 | |||
3809 | state._fsp--; | ||
3810 | |||
3811 | |||
3812 | current = this_ConstantAssertionArgument_1; | ||
3813 | afterParserOrEnumRuleCall(); | ||
3814 | |||
3815 | |||
3816 | } | ||
3817 | break; | ||
3818 | |||
3819 | } | ||
3820 | |||
3821 | |||
3822 | } | ||
3823 | |||
3824 | |||
3825 | leaveRule(); | ||
3826 | |||
3827 | } | ||
3828 | |||
3829 | catch (RecognitionException re) { | ||
3830 | recover(input,re); | ||
3831 | appendSkippedTokens(); | ||
3832 | } | ||
3833 | finally { | ||
3834 | } | ||
3835 | return current; | ||
3836 | } | ||
3837 | // $ANTLR end "ruleAssertionArgument" | ||
3838 | |||
3839 | |||
3840 | // $ANTLR start "entryRuleNodeAssertionArgument" | ||
3841 | // InternalProblem.g:1452:1: entryRuleNodeAssertionArgument returns [EObject current=null] : iv_ruleNodeAssertionArgument= ruleNodeAssertionArgument EOF ; | ||
3842 | public final EObject entryRuleNodeAssertionArgument() throws RecognitionException { | ||
3843 | EObject current = null; | ||
3844 | |||
3845 | EObject iv_ruleNodeAssertionArgument = null; | ||
3846 | |||
3847 | |||
3848 | try { | ||
3849 | // InternalProblem.g:1452:62: (iv_ruleNodeAssertionArgument= ruleNodeAssertionArgument EOF ) | ||
3850 | // InternalProblem.g:1453:2: iv_ruleNodeAssertionArgument= ruleNodeAssertionArgument EOF | ||
3851 | { | ||
3852 | newCompositeNode(grammarAccess.getNodeAssertionArgumentRule()); | ||
3853 | pushFollow(FOLLOW_1); | ||
3854 | iv_ruleNodeAssertionArgument=ruleNodeAssertionArgument(); | ||
3855 | |||
3856 | state._fsp--; | ||
3857 | |||
3858 | current =iv_ruleNodeAssertionArgument; | ||
3859 | match(input,EOF,FOLLOW_2); | ||
3860 | |||
3861 | } | ||
3862 | |||
3863 | } | ||
3864 | |||
3865 | catch (RecognitionException re) { | ||
3866 | recover(input,re); | ||
3867 | appendSkippedTokens(); | ||
3868 | } | ||
3869 | finally { | ||
3870 | } | ||
3871 | return current; | ||
3872 | } | ||
3873 | // $ANTLR end "entryRuleNodeAssertionArgument" | ||
3874 | |||
3875 | |||
3876 | // $ANTLR start "ruleNodeAssertionArgument" | ||
3877 | // InternalProblem.g:1459:1: ruleNodeAssertionArgument returns [EObject current=null] : ( ( ruleQualifiedName ) ) ; | ||
3878 | public final EObject ruleNodeAssertionArgument() throws RecognitionException { | ||
3879 | EObject current = null; | ||
3880 | |||
3881 | |||
3882 | enterRule(); | ||
3883 | |||
3884 | try { | ||
3885 | // InternalProblem.g:1465:2: ( ( ( ruleQualifiedName ) ) ) | ||
3886 | // InternalProblem.g:1466:2: ( ( ruleQualifiedName ) ) | ||
3887 | { | ||
3888 | // InternalProblem.g:1466:2: ( ( ruleQualifiedName ) ) | ||
3889 | // InternalProblem.g:1467:3: ( ruleQualifiedName ) | ||
3890 | { | ||
3891 | // InternalProblem.g:1467:3: ( ruleQualifiedName ) | ||
3892 | // InternalProblem.g:1468:4: ruleQualifiedName | ||
3893 | { | ||
3894 | |||
3895 | if (current==null) { | ||
3896 | current = createModelElement(grammarAccess.getNodeAssertionArgumentRule()); | ||
3897 | } | ||
3898 | |||
3899 | |||
3900 | newCompositeNode(grammarAccess.getNodeAssertionArgumentAccess().getNodeNodeCrossReference_0()); | ||
3901 | |||
3902 | pushFollow(FOLLOW_2); | ||
3903 | ruleQualifiedName(); | ||
3904 | |||
3905 | state._fsp--; | ||
3906 | |||
3907 | |||
3908 | afterParserOrEnumRuleCall(); | ||
3909 | |||
3910 | |||
3911 | } | ||
3912 | |||
3913 | |||
3914 | } | ||
3915 | |||
3916 | |||
3917 | } | ||
3918 | |||
3919 | |||
3920 | leaveRule(); | ||
3921 | |||
3922 | } | ||
3923 | |||
3924 | catch (RecognitionException re) { | ||
3925 | recover(input,re); | ||
3926 | appendSkippedTokens(); | ||
3927 | } | ||
3928 | finally { | ||
3929 | } | ||
3930 | return current; | ||
3931 | } | ||
3932 | // $ANTLR end "ruleNodeAssertionArgument" | ||
3933 | |||
3934 | |||
3935 | // $ANTLR start "entryRuleConstantAssertionArgument" | ||
3936 | // InternalProblem.g:1485:1: entryRuleConstantAssertionArgument returns [EObject current=null] : iv_ruleConstantAssertionArgument= ruleConstantAssertionArgument EOF ; | ||
3937 | public final EObject entryRuleConstantAssertionArgument() throws RecognitionException { | ||
3938 | EObject current = null; | ||
3939 | |||
3940 | EObject iv_ruleConstantAssertionArgument = null; | ||
3941 | |||
3942 | |||
3943 | try { | ||
3944 | // InternalProblem.g:1485:66: (iv_ruleConstantAssertionArgument= ruleConstantAssertionArgument EOF ) | ||
3945 | // InternalProblem.g:1486:2: iv_ruleConstantAssertionArgument= ruleConstantAssertionArgument EOF | ||
3946 | { | ||
3947 | newCompositeNode(grammarAccess.getConstantAssertionArgumentRule()); | ||
3948 | pushFollow(FOLLOW_1); | ||
3949 | iv_ruleConstantAssertionArgument=ruleConstantAssertionArgument(); | ||
3950 | |||
3951 | state._fsp--; | ||
3952 | |||
3953 | current =iv_ruleConstantAssertionArgument; | ||
3954 | match(input,EOF,FOLLOW_2); | ||
3955 | |||
3956 | } | ||
3957 | |||
3958 | } | ||
3959 | |||
3960 | catch (RecognitionException re) { | ||
3961 | recover(input,re); | ||
3962 | appendSkippedTokens(); | ||
3963 | } | ||
3964 | finally { | ||
3965 | } | ||
3966 | return current; | ||
3967 | } | ||
3968 | // $ANTLR end "entryRuleConstantAssertionArgument" | ||
3969 | |||
3970 | |||
3971 | // $ANTLR start "ruleConstantAssertionArgument" | ||
3972 | // InternalProblem.g:1492:1: ruleConstantAssertionArgument returns [EObject current=null] : ( (lv_constant_0_0= ruleConstant ) ) ; | ||
3973 | public final EObject ruleConstantAssertionArgument() throws RecognitionException { | ||
3974 | EObject current = null; | ||
3975 | |||
3976 | EObject lv_constant_0_0 = null; | ||
3977 | |||
3978 | |||
3979 | |||
3980 | enterRule(); | ||
3981 | |||
3982 | try { | ||
3983 | // InternalProblem.g:1498:2: ( ( (lv_constant_0_0= ruleConstant ) ) ) | ||
3984 | // InternalProblem.g:1499:2: ( (lv_constant_0_0= ruleConstant ) ) | ||
3985 | { | ||
3986 | // InternalProblem.g:1499:2: ( (lv_constant_0_0= ruleConstant ) ) | ||
3987 | // InternalProblem.g:1500:3: (lv_constant_0_0= ruleConstant ) | ||
3988 | { | ||
3989 | // InternalProblem.g:1500:3: (lv_constant_0_0= ruleConstant ) | ||
3990 | // InternalProblem.g:1501:4: lv_constant_0_0= ruleConstant | ||
3991 | { | ||
3992 | |||
3993 | newCompositeNode(grammarAccess.getConstantAssertionArgumentAccess().getConstantConstantParserRuleCall_0()); | ||
3994 | |||
3995 | pushFollow(FOLLOW_2); | ||
3996 | lv_constant_0_0=ruleConstant(); | ||
3997 | |||
3998 | state._fsp--; | ||
3999 | |||
4000 | |||
4001 | if (current==null) { | ||
4002 | current = createModelElementForParent(grammarAccess.getConstantAssertionArgumentRule()); | ||
4003 | } | ||
4004 | set( | ||
4005 | current, | ||
4006 | "constant", | ||
4007 | lv_constant_0_0, | ||
4008 | "org.eclipse.viatra.solver.language.Problem.Constant"); | ||
4009 | afterParserOrEnumRuleCall(); | ||
4010 | |||
4011 | |||
4012 | } | ||
4013 | |||
4014 | |||
4015 | } | ||
4016 | |||
4017 | |||
4018 | } | ||
4019 | |||
4020 | |||
4021 | leaveRule(); | ||
4022 | |||
4023 | } | ||
4024 | |||
4025 | catch (RecognitionException re) { | ||
4026 | recover(input,re); | ||
4027 | appendSkippedTokens(); | ||
4028 | } | ||
4029 | finally { | ||
4030 | } | ||
4031 | return current; | ||
4032 | } | ||
4033 | // $ANTLR end "ruleConstantAssertionArgument" | ||
4034 | |||
4035 | |||
4036 | // $ANTLR start "entryRuleNodeValueAssertion" | ||
4037 | // InternalProblem.g:1521:1: entryRuleNodeValueAssertion returns [EObject current=null] : iv_ruleNodeValueAssertion= ruleNodeValueAssertion EOF ; | ||
4038 | public final EObject entryRuleNodeValueAssertion() throws RecognitionException { | ||
4039 | EObject current = null; | ||
4040 | |||
4041 | EObject iv_ruleNodeValueAssertion = null; | ||
4042 | |||
4043 | |||
4044 | try { | ||
4045 | // InternalProblem.g:1521:59: (iv_ruleNodeValueAssertion= ruleNodeValueAssertion EOF ) | ||
4046 | // InternalProblem.g:1522:2: iv_ruleNodeValueAssertion= ruleNodeValueAssertion EOF | ||
4047 | { | ||
4048 | newCompositeNode(grammarAccess.getNodeValueAssertionRule()); | ||
4049 | pushFollow(FOLLOW_1); | ||
4050 | iv_ruleNodeValueAssertion=ruleNodeValueAssertion(); | ||
4051 | |||
4052 | state._fsp--; | ||
4053 | |||
4054 | current =iv_ruleNodeValueAssertion; | ||
4055 | match(input,EOF,FOLLOW_2); | ||
4056 | |||
4057 | } | ||
4058 | |||
4059 | } | ||
4060 | |||
4061 | catch (RecognitionException re) { | ||
4062 | recover(input,re); | ||
4063 | appendSkippedTokens(); | ||
4064 | } | ||
4065 | finally { | ||
4066 | } | ||
4067 | return current; | ||
4068 | } | ||
4069 | // $ANTLR end "entryRuleNodeValueAssertion" | ||
4070 | |||
4071 | |||
4072 | // $ANTLR start "ruleNodeValueAssertion" | ||
4073 | // InternalProblem.g:1528:1: ruleNodeValueAssertion returns [EObject current=null] : ( ( ( ruleQualifiedName ) ) otherlv_1= ':' ( (lv_value_2_0= ruleConstant ) ) otherlv_3= '.' ) ; | ||
4074 | public final EObject ruleNodeValueAssertion() throws RecognitionException { | ||
4075 | EObject current = null; | ||
4076 | |||
4077 | Token otherlv_1=null; | ||
4078 | Token otherlv_3=null; | ||
4079 | EObject lv_value_2_0 = null; | ||
4080 | |||
4081 | |||
4082 | |||
4083 | enterRule(); | ||
4084 | |||
4085 | try { | ||
4086 | // InternalProblem.g:1534:2: ( ( ( ( ruleQualifiedName ) ) otherlv_1= ':' ( (lv_value_2_0= ruleConstant ) ) otherlv_3= '.' ) ) | ||
4087 | // InternalProblem.g:1535:2: ( ( ( ruleQualifiedName ) ) otherlv_1= ':' ( (lv_value_2_0= ruleConstant ) ) otherlv_3= '.' ) | ||
4088 | { | ||
4089 | // InternalProblem.g:1535:2: ( ( ( ruleQualifiedName ) ) otherlv_1= ':' ( (lv_value_2_0= ruleConstant ) ) otherlv_3= '.' ) | ||
4090 | // InternalProblem.g:1536:3: ( ( ruleQualifiedName ) ) otherlv_1= ':' ( (lv_value_2_0= ruleConstant ) ) otherlv_3= '.' | ||
4091 | { | ||
4092 | // InternalProblem.g:1536:3: ( ( ruleQualifiedName ) ) | ||
4093 | // InternalProblem.g:1537:4: ( ruleQualifiedName ) | ||
4094 | { | ||
4095 | // InternalProblem.g:1537:4: ( ruleQualifiedName ) | ||
4096 | // InternalProblem.g:1538:5: ruleQualifiedName | ||
4097 | { | ||
4098 | |||
4099 | if (current==null) { | ||
4100 | current = createModelElement(grammarAccess.getNodeValueAssertionRule()); | ||
4101 | } | ||
4102 | |||
4103 | |||
4104 | newCompositeNode(grammarAccess.getNodeValueAssertionAccess().getNodeNodeCrossReference_0_0()); | ||
4105 | |||
4106 | pushFollow(FOLLOW_31); | ||
4107 | ruleQualifiedName(); | ||
4108 | |||
4109 | state._fsp--; | ||
4110 | |||
4111 | |||
4112 | afterParserOrEnumRuleCall(); | ||
4113 | |||
4114 | |||
4115 | } | ||
4116 | |||
4117 | |||
4118 | } | ||
4119 | |||
4120 | otherlv_1=(Token)match(input,34,FOLLOW_30); | ||
4121 | |||
4122 | newLeafNode(otherlv_1, grammarAccess.getNodeValueAssertionAccess().getColonKeyword_1()); | ||
4123 | |||
4124 | // InternalProblem.g:1556:3: ( (lv_value_2_0= ruleConstant ) ) | ||
4125 | // InternalProblem.g:1557:4: (lv_value_2_0= ruleConstant ) | ||
4126 | { | ||
4127 | // InternalProblem.g:1557:4: (lv_value_2_0= ruleConstant ) | ||
4128 | // InternalProblem.g:1558:5: lv_value_2_0= ruleConstant | ||
4129 | { | ||
4130 | |||
4131 | newCompositeNode(grammarAccess.getNodeValueAssertionAccess().getValueConstantParserRuleCall_2_0()); | ||
4132 | |||
4133 | pushFollow(FOLLOW_4); | ||
4134 | lv_value_2_0=ruleConstant(); | ||
4135 | |||
4136 | state._fsp--; | ||
4137 | |||
4138 | |||
4139 | if (current==null) { | ||
4140 | current = createModelElementForParent(grammarAccess.getNodeValueAssertionRule()); | ||
4141 | } | ||
4142 | set( | ||
4143 | current, | ||
4144 | "value", | ||
4145 | lv_value_2_0, | ||
4146 | "org.eclipse.viatra.solver.language.Problem.Constant"); | ||
4147 | afterParserOrEnumRuleCall(); | ||
4148 | |||
4149 | |||
4150 | } | ||
4151 | |||
4152 | |||
4153 | } | ||
4154 | |||
4155 | otherlv_3=(Token)match(input,13,FOLLOW_2); | ||
4156 | |||
4157 | newLeafNode(otherlv_3, grammarAccess.getNodeValueAssertionAccess().getFullStopKeyword_3()); | ||
4158 | |||
4159 | |||
4160 | } | ||
4161 | |||
4162 | |||
4163 | } | ||
4164 | |||
4165 | |||
4166 | leaveRule(); | ||
4167 | |||
4168 | } | ||
4169 | |||
4170 | catch (RecognitionException re) { | ||
4171 | recover(input,re); | ||
4172 | appendSkippedTokens(); | ||
4173 | } | ||
4174 | finally { | ||
4175 | } | ||
4176 | return current; | ||
4177 | } | ||
4178 | // $ANTLR end "ruleNodeValueAssertion" | ||
4179 | |||
4180 | |||
4181 | // $ANTLR start "entryRuleConstant" | ||
4182 | // InternalProblem.g:1583:1: entryRuleConstant returns [EObject current=null] : iv_ruleConstant= ruleConstant EOF ; | ||
4183 | public final EObject entryRuleConstant() throws RecognitionException { | ||
4184 | EObject current = null; | ||
4185 | |||
4186 | EObject iv_ruleConstant = null; | ||
4187 | |||
4188 | |||
4189 | try { | ||
4190 | // InternalProblem.g:1583:49: (iv_ruleConstant= ruleConstant EOF ) | ||
4191 | // InternalProblem.g:1584:2: iv_ruleConstant= ruleConstant EOF | ||
4192 | { | ||
4193 | newCompositeNode(grammarAccess.getConstantRule()); | ||
4194 | pushFollow(FOLLOW_1); | ||
4195 | iv_ruleConstant=ruleConstant(); | ||
4196 | |||
4197 | state._fsp--; | ||
4198 | |||
4199 | current =iv_ruleConstant; | ||
4200 | match(input,EOF,FOLLOW_2); | ||
4201 | |||
4202 | } | ||
4203 | |||
4204 | } | ||
4205 | |||
4206 | catch (RecognitionException re) { | ||
4207 | recover(input,re); | ||
4208 | appendSkippedTokens(); | ||
4209 | } | ||
4210 | finally { | ||
4211 | } | ||
4212 | return current; | ||
4213 | } | ||
4214 | // $ANTLR end "entryRuleConstant" | ||
4215 | |||
4216 | |||
4217 | // $ANTLR start "ruleConstant" | ||
4218 | // InternalProblem.g:1590:1: ruleConstant returns [EObject current=null] : (this_IntConstant_0= ruleIntConstant | this_RealConstant_1= ruleRealConstant | this_StringConstant_2= ruleStringConstant ) ; | ||
4219 | public final EObject ruleConstant() throws RecognitionException { | ||
4220 | EObject current = null; | ||
4221 | |||
4222 | EObject this_IntConstant_0 = null; | ||
4223 | |||
4224 | EObject this_RealConstant_1 = null; | ||
4225 | |||
4226 | EObject this_StringConstant_2 = null; | ||
4227 | |||
4228 | |||
4229 | |||
4230 | enterRule(); | ||
4231 | |||
4232 | try { | ||
4233 | // InternalProblem.g:1596:2: ( (this_IntConstant_0= ruleIntConstant | this_RealConstant_1= ruleRealConstant | this_StringConstant_2= ruleStringConstant ) ) | ||
4234 | // InternalProblem.g:1597:2: (this_IntConstant_0= ruleIntConstant | this_RealConstant_1= ruleRealConstant | this_StringConstant_2= ruleStringConstant ) | ||
4235 | { | ||
4236 | // InternalProblem.g:1597:2: (this_IntConstant_0= ruleIntConstant | this_RealConstant_1= ruleRealConstant | this_StringConstant_2= ruleStringConstant ) | ||
4237 | int alt37=3; | ||
4238 | switch ( input.LA(1) ) { | ||
4239 | case 45: | ||
4240 | { | ||
4241 | int LA37_1 = input.LA(2); | ||
4242 | |||
4243 | if ( (LA37_1==RULE_INT) ) { | ||
4244 | switch ( input.LA(3) ) { | ||
4245 | case 13: | ||
4246 | { | ||
4247 | int LA37_4 = input.LA(4); | ||
4248 | |||
4249 | if ( (LA37_4==RULE_INT) ) { | ||
4250 | alt37=2; | ||
4251 | } | ||
4252 | else if ( (LA37_4==EOF||LA37_4==RULE_ID||LA37_4==RULE_QUOTED_ID||(LA37_4>=14 && LA37_4<=15)||LA37_4==21||(LA37_4>=27 && LA37_4<=28)||LA37_4==32||LA37_4==35||(LA37_4>=41 && LA37_4<=44)||LA37_4==47) ) { | ||
4253 | alt37=1; | ||
4254 | } | ||
4255 | else { | ||
4256 | NoViableAltException nvae = | ||
4257 | new NoViableAltException("", 37, 4, input); | ||
4258 | |||
4259 | throw nvae; | ||
4260 | } | ||
4261 | } | ||
4262 | break; | ||
4263 | case 43: | ||
4264 | case 44: | ||
4265 | { | ||
4266 | alt37=2; | ||
4267 | } | ||
4268 | break; | ||
4269 | case EOF: | ||
4270 | case 17: | ||
4271 | case 30: | ||
4272 | { | ||
4273 | alt37=1; | ||
4274 | } | ||
4275 | break; | ||
4276 | default: | ||
4277 | NoViableAltException nvae = | ||
4278 | new NoViableAltException("", 37, 2, input); | ||
4279 | |||
4280 | throw nvae; | ||
4281 | } | ||
4282 | |||
4283 | } | ||
4284 | else { | ||
4285 | NoViableAltException nvae = | ||
4286 | new NoViableAltException("", 37, 1, input); | ||
4287 | |||
4288 | throw nvae; | ||
4289 | } | ||
4290 | } | ||
4291 | break; | ||
4292 | case RULE_INT: | ||
4293 | { | ||
4294 | switch ( input.LA(2) ) { | ||
4295 | case 13: | ||
4296 | { | ||
4297 | int LA37_4 = input.LA(3); | ||
4298 | |||
4299 | if ( (LA37_4==RULE_INT) ) { | ||
4300 | alt37=2; | ||
4301 | } | ||
4302 | else if ( (LA37_4==EOF||LA37_4==RULE_ID||LA37_4==RULE_QUOTED_ID||(LA37_4>=14 && LA37_4<=15)||LA37_4==21||(LA37_4>=27 && LA37_4<=28)||LA37_4==32||LA37_4==35||(LA37_4>=41 && LA37_4<=44)||LA37_4==47) ) { | ||
4303 | alt37=1; | ||
4304 | } | ||
4305 | else { | ||
4306 | NoViableAltException nvae = | ||
4307 | new NoViableAltException("", 37, 4, input); | ||
4308 | |||
4309 | throw nvae; | ||
4310 | } | ||
4311 | } | ||
4312 | break; | ||
4313 | case 43: | ||
4314 | case 44: | ||
4315 | { | ||
4316 | alt37=2; | ||
4317 | } | ||
4318 | break; | ||
4319 | case EOF: | ||
4320 | case 17: | ||
4321 | case 30: | ||
4322 | { | ||
4323 | alt37=1; | ||
4324 | } | ||
4325 | break; | ||
4326 | default: | ||
4327 | NoViableAltException nvae = | ||
4328 | new NoViableAltException("", 37, 2, input); | ||
4329 | |||
4330 | throw nvae; | ||
4331 | } | ||
4332 | |||
4333 | } | ||
4334 | break; | ||
4335 | case RULE_STRING: | ||
4336 | { | ||
4337 | alt37=3; | ||
4338 | } | ||
4339 | break; | ||
4340 | default: | ||
4341 | NoViableAltException nvae = | ||
4342 | new NoViableAltException("", 37, 0, input); | ||
4343 | |||
4344 | throw nvae; | ||
4345 | } | ||
4346 | |||
4347 | switch (alt37) { | ||
4348 | case 1 : | ||
4349 | // InternalProblem.g:1598:3: this_IntConstant_0= ruleIntConstant | ||
4350 | { | ||
4351 | |||
4352 | newCompositeNode(grammarAccess.getConstantAccess().getIntConstantParserRuleCall_0()); | ||
4353 | |||
4354 | pushFollow(FOLLOW_2); | ||
4355 | this_IntConstant_0=ruleIntConstant(); | ||
4356 | |||
4357 | state._fsp--; | ||
4358 | |||
4359 | |||
4360 | current = this_IntConstant_0; | ||
4361 | afterParserOrEnumRuleCall(); | ||
4362 | |||
4363 | |||
4364 | } | ||
4365 | break; | ||
4366 | case 2 : | ||
4367 | // InternalProblem.g:1607:3: this_RealConstant_1= ruleRealConstant | ||
4368 | { | ||
4369 | |||
4370 | newCompositeNode(grammarAccess.getConstantAccess().getRealConstantParserRuleCall_1()); | ||
4371 | |||
4372 | pushFollow(FOLLOW_2); | ||
4373 | this_RealConstant_1=ruleRealConstant(); | ||
4374 | |||
4375 | state._fsp--; | ||
4376 | |||
4377 | |||
4378 | current = this_RealConstant_1; | ||
4379 | afterParserOrEnumRuleCall(); | ||
4380 | |||
4381 | |||
4382 | } | ||
4383 | break; | ||
4384 | case 3 : | ||
4385 | // InternalProblem.g:1616:3: this_StringConstant_2= ruleStringConstant | ||
4386 | { | ||
4387 | |||
4388 | newCompositeNode(grammarAccess.getConstantAccess().getStringConstantParserRuleCall_2()); | ||
4389 | |||
4390 | pushFollow(FOLLOW_2); | ||
4391 | this_StringConstant_2=ruleStringConstant(); | ||
4392 | |||
4393 | state._fsp--; | ||
4394 | |||
4395 | |||
4396 | current = this_StringConstant_2; | ||
4397 | afterParserOrEnumRuleCall(); | ||
4398 | |||
4399 | |||
4400 | } | ||
4401 | break; | ||
4402 | |||
4403 | } | ||
4404 | |||
4405 | |||
4406 | } | ||
4407 | |||
4408 | |||
4409 | leaveRule(); | ||
4410 | |||
4411 | } | ||
4412 | |||
4413 | catch (RecognitionException re) { | ||
4414 | recover(input,re); | ||
4415 | appendSkippedTokens(); | ||
4416 | } | ||
4417 | finally { | ||
4418 | } | ||
4419 | return current; | ||
4420 | } | ||
4421 | // $ANTLR end "ruleConstant" | ||
4422 | |||
4423 | |||
4424 | // $ANTLR start "entryRuleIntConstant" | ||
4425 | // InternalProblem.g:1628:1: entryRuleIntConstant returns [EObject current=null] : iv_ruleIntConstant= ruleIntConstant EOF ; | ||
4426 | public final EObject entryRuleIntConstant() throws RecognitionException { | ||
4427 | EObject current = null; | ||
4428 | |||
4429 | EObject iv_ruleIntConstant = null; | ||
4430 | |||
4431 | |||
4432 | try { | ||
4433 | // InternalProblem.g:1628:52: (iv_ruleIntConstant= ruleIntConstant EOF ) | ||
4434 | // InternalProblem.g:1629:2: iv_ruleIntConstant= ruleIntConstant EOF | ||
4435 | { | ||
4436 | newCompositeNode(grammarAccess.getIntConstantRule()); | ||
4437 | pushFollow(FOLLOW_1); | ||
4438 | iv_ruleIntConstant=ruleIntConstant(); | ||
4439 | |||
4440 | state._fsp--; | ||
4441 | |||
4442 | current =iv_ruleIntConstant; | ||
4443 | match(input,EOF,FOLLOW_2); | ||
4444 | |||
4445 | } | ||
4446 | |||
4447 | } | ||
4448 | |||
4449 | catch (RecognitionException re) { | ||
4450 | recover(input,re); | ||
4451 | appendSkippedTokens(); | ||
4452 | } | ||
4453 | finally { | ||
4454 | } | ||
4455 | return current; | ||
4456 | } | ||
4457 | // $ANTLR end "entryRuleIntConstant" | ||
4458 | |||
4459 | |||
4460 | // $ANTLR start "ruleIntConstant" | ||
4461 | // InternalProblem.g:1635:1: ruleIntConstant returns [EObject current=null] : ( (lv_intValue_0_0= ruleInteger ) ) ; | ||
4462 | public final EObject ruleIntConstant() throws RecognitionException { | ||
4463 | EObject current = null; | ||
4464 | |||
4465 | AntlrDatatypeRuleToken lv_intValue_0_0 = null; | ||
4466 | |||
4467 | |||
4468 | |||
4469 | enterRule(); | ||
4470 | |||
4471 | try { | ||
4472 | // InternalProblem.g:1641:2: ( ( (lv_intValue_0_0= ruleInteger ) ) ) | ||
4473 | // InternalProblem.g:1642:2: ( (lv_intValue_0_0= ruleInteger ) ) | ||
4474 | { | ||
4475 | // InternalProblem.g:1642:2: ( (lv_intValue_0_0= ruleInteger ) ) | ||
4476 | // InternalProblem.g:1643:3: (lv_intValue_0_0= ruleInteger ) | ||
4477 | { | ||
4478 | // InternalProblem.g:1643:3: (lv_intValue_0_0= ruleInteger ) | ||
4479 | // InternalProblem.g:1644:4: lv_intValue_0_0= ruleInteger | ||
4480 | { | ||
4481 | |||
4482 | newCompositeNode(grammarAccess.getIntConstantAccess().getIntValueIntegerParserRuleCall_0()); | ||
4483 | |||
4484 | pushFollow(FOLLOW_2); | ||
4485 | lv_intValue_0_0=ruleInteger(); | ||
4486 | |||
4487 | state._fsp--; | ||
4488 | |||
4489 | |||
4490 | if (current==null) { | ||
4491 | current = createModelElementForParent(grammarAccess.getIntConstantRule()); | ||
4492 | } | ||
4493 | set( | ||
4494 | current, | ||
4495 | "intValue", | ||
4496 | lv_intValue_0_0, | ||
4497 | "org.eclipse.viatra.solver.language.Problem.Integer"); | ||
4498 | afterParserOrEnumRuleCall(); | ||
4499 | |||
4500 | |||
4501 | } | ||
4502 | |||
4503 | |||
4504 | } | ||
4505 | |||
4506 | |||
4507 | } | ||
4508 | |||
4509 | |||
4510 | leaveRule(); | ||
4511 | |||
4512 | } | ||
4513 | |||
4514 | catch (RecognitionException re) { | ||
4515 | recover(input,re); | ||
4516 | appendSkippedTokens(); | ||
4517 | } | ||
4518 | finally { | ||
4519 | } | ||
4520 | return current; | ||
4521 | } | ||
4522 | // $ANTLR end "ruleIntConstant" | ||
4523 | |||
4524 | |||
4525 | // $ANTLR start "entryRuleRealConstant" | ||
4526 | // InternalProblem.g:1664:1: entryRuleRealConstant returns [EObject current=null] : iv_ruleRealConstant= ruleRealConstant EOF ; | ||
4527 | public final EObject entryRuleRealConstant() throws RecognitionException { | ||
4528 | EObject current = null; | ||
4529 | |||
4530 | EObject iv_ruleRealConstant = null; | ||
4531 | |||
4532 | |||
4533 | try { | ||
4534 | // InternalProblem.g:1664:53: (iv_ruleRealConstant= ruleRealConstant EOF ) | ||
4535 | // InternalProblem.g:1665:2: iv_ruleRealConstant= ruleRealConstant EOF | ||
4536 | { | ||
4537 | newCompositeNode(grammarAccess.getRealConstantRule()); | ||
4538 | pushFollow(FOLLOW_1); | ||
4539 | iv_ruleRealConstant=ruleRealConstant(); | ||
4540 | |||
4541 | state._fsp--; | ||
4542 | |||
4543 | current =iv_ruleRealConstant; | ||
4544 | match(input,EOF,FOLLOW_2); | ||
4545 | |||
4546 | } | ||
4547 | |||
4548 | } | ||
4549 | |||
4550 | catch (RecognitionException re) { | ||
4551 | recover(input,re); | ||
4552 | appendSkippedTokens(); | ||
4553 | } | ||
4554 | finally { | ||
4555 | } | ||
4556 | return current; | ||
4557 | } | ||
4558 | // $ANTLR end "entryRuleRealConstant" | ||
4559 | |||
4560 | |||
4561 | // $ANTLR start "ruleRealConstant" | ||
4562 | // InternalProblem.g:1671:1: ruleRealConstant returns [EObject current=null] : ( (lv_realValue_0_0= ruleReal ) ) ; | ||
4563 | public final EObject ruleRealConstant() throws RecognitionException { | ||
4564 | EObject current = null; | ||
4565 | |||
4566 | AntlrDatatypeRuleToken lv_realValue_0_0 = null; | ||
4567 | |||
4568 | |||
4569 | |||
4570 | enterRule(); | ||
4571 | |||
4572 | try { | ||
4573 | // InternalProblem.g:1677:2: ( ( (lv_realValue_0_0= ruleReal ) ) ) | ||
4574 | // InternalProblem.g:1678:2: ( (lv_realValue_0_0= ruleReal ) ) | ||
4575 | { | ||
4576 | // InternalProblem.g:1678:2: ( (lv_realValue_0_0= ruleReal ) ) | ||
4577 | // InternalProblem.g:1679:3: (lv_realValue_0_0= ruleReal ) | ||
4578 | { | ||
4579 | // InternalProblem.g:1679:3: (lv_realValue_0_0= ruleReal ) | ||
4580 | // InternalProblem.g:1680:4: lv_realValue_0_0= ruleReal | ||
4581 | { | ||
4582 | |||
4583 | newCompositeNode(grammarAccess.getRealConstantAccess().getRealValueRealParserRuleCall_0()); | ||
4584 | |||
4585 | pushFollow(FOLLOW_2); | ||
4586 | lv_realValue_0_0=ruleReal(); | ||
4587 | |||
4588 | state._fsp--; | ||
4589 | |||
4590 | |||
4591 | if (current==null) { | ||
4592 | current = createModelElementForParent(grammarAccess.getRealConstantRule()); | ||
4593 | } | ||
4594 | set( | ||
4595 | current, | ||
4596 | "realValue", | ||
4597 | lv_realValue_0_0, | ||
4598 | "org.eclipse.viatra.solver.language.Problem.Real"); | ||
4599 | afterParserOrEnumRuleCall(); | ||
4600 | |||
4601 | |||
4602 | } | ||
4603 | |||
4604 | |||
4605 | } | ||
4606 | |||
4607 | |||
4608 | } | ||
4609 | |||
4610 | |||
4611 | leaveRule(); | ||
4612 | |||
4613 | } | ||
4614 | |||
4615 | catch (RecognitionException re) { | ||
4616 | recover(input,re); | ||
4617 | appendSkippedTokens(); | ||
4618 | } | ||
4619 | finally { | ||
4620 | } | ||
4621 | return current; | ||
4622 | } | ||
4623 | // $ANTLR end "ruleRealConstant" | ||
4624 | |||
4625 | |||
4626 | // $ANTLR start "entryRuleStringConstant" | ||
4627 | // InternalProblem.g:1700:1: entryRuleStringConstant returns [EObject current=null] : iv_ruleStringConstant= ruleStringConstant EOF ; | ||
4628 | public final EObject entryRuleStringConstant() throws RecognitionException { | ||
4629 | EObject current = null; | ||
4630 | |||
4631 | EObject iv_ruleStringConstant = null; | ||
4632 | |||
4633 | |||
4634 | try { | ||
4635 | // InternalProblem.g:1700:55: (iv_ruleStringConstant= ruleStringConstant EOF ) | ||
4636 | // InternalProblem.g:1701:2: iv_ruleStringConstant= ruleStringConstant EOF | ||
4637 | { | ||
4638 | newCompositeNode(grammarAccess.getStringConstantRule()); | ||
4639 | pushFollow(FOLLOW_1); | ||
4640 | iv_ruleStringConstant=ruleStringConstant(); | ||
4641 | |||
4642 | state._fsp--; | ||
4643 | |||
4644 | current =iv_ruleStringConstant; | ||
4645 | match(input,EOF,FOLLOW_2); | ||
4646 | |||
4647 | } | ||
4648 | |||
4649 | } | ||
4650 | |||
4651 | catch (RecognitionException re) { | ||
4652 | recover(input,re); | ||
4653 | appendSkippedTokens(); | ||
4654 | } | ||
4655 | finally { | ||
4656 | } | ||
4657 | return current; | ||
4658 | } | ||
4659 | // $ANTLR end "entryRuleStringConstant" | ||
4660 | |||
4661 | |||
4662 | // $ANTLR start "ruleStringConstant" | ||
4663 | // InternalProblem.g:1707:1: ruleStringConstant returns [EObject current=null] : ( (lv_stringValue_0_0= RULE_STRING ) ) ; | ||
4664 | public final EObject ruleStringConstant() throws RecognitionException { | ||
4665 | EObject current = null; | ||
4666 | |||
4667 | Token lv_stringValue_0_0=null; | ||
4668 | |||
4669 | |||
4670 | enterRule(); | ||
4671 | |||
4672 | try { | ||
4673 | // InternalProblem.g:1713:2: ( ( (lv_stringValue_0_0= RULE_STRING ) ) ) | ||
4674 | // InternalProblem.g:1714:2: ( (lv_stringValue_0_0= RULE_STRING ) ) | ||
4675 | { | ||
4676 | // InternalProblem.g:1714:2: ( (lv_stringValue_0_0= RULE_STRING ) ) | ||
4677 | // InternalProblem.g:1715:3: (lv_stringValue_0_0= RULE_STRING ) | ||
4678 | { | ||
4679 | // InternalProblem.g:1715:3: (lv_stringValue_0_0= RULE_STRING ) | ||
4680 | // InternalProblem.g:1716:4: lv_stringValue_0_0= RULE_STRING | ||
4681 | { | ||
4682 | lv_stringValue_0_0=(Token)match(input,RULE_STRING,FOLLOW_2); | ||
4683 | |||
4684 | newLeafNode(lv_stringValue_0_0, grammarAccess.getStringConstantAccess().getStringValueSTRINGTerminalRuleCall_0()); | ||
4685 | |||
4686 | |||
4687 | if (current==null) { | ||
4688 | current = createModelElement(grammarAccess.getStringConstantRule()); | ||
4689 | } | ||
4690 | setWithLastConsumed( | ||
4691 | current, | ||
4692 | "stringValue", | ||
4693 | lv_stringValue_0_0, | ||
4694 | "org.eclipse.viatra.solver.language.Problem.STRING"); | ||
4695 | |||
4696 | |||
4697 | } | ||
4698 | |||
4699 | |||
4700 | } | ||
4701 | |||
4702 | |||
4703 | } | ||
4704 | |||
4705 | |||
4706 | leaveRule(); | ||
4707 | |||
4708 | } | ||
4709 | |||
4710 | catch (RecognitionException re) { | ||
4711 | recover(input,re); | ||
4712 | appendSkippedTokens(); | ||
4713 | } | ||
4714 | finally { | ||
4715 | } | ||
4716 | return current; | ||
4717 | } | ||
4718 | // $ANTLR end "ruleStringConstant" | ||
4719 | |||
4720 | |||
3461 | // $ANTLR start "entryRuleScopeDeclaration" | 4721 | // $ANTLR start "entryRuleScopeDeclaration" |
3462 | // InternalProblem.g:1323:1: entryRuleScopeDeclaration returns [EObject current=null] : iv_ruleScopeDeclaration= ruleScopeDeclaration EOF ; | 4722 | // InternalProblem.g:1735:1: entryRuleScopeDeclaration returns [EObject current=null] : iv_ruleScopeDeclaration= ruleScopeDeclaration EOF ; |
3463 | public final EObject entryRuleScopeDeclaration() throws RecognitionException { | 4723 | public final EObject entryRuleScopeDeclaration() throws RecognitionException { |
3464 | EObject current = null; | 4724 | EObject current = null; |
3465 | 4725 | ||
@@ -3467,8 +4727,8 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3467 | 4727 | ||
3468 | 4728 | ||
3469 | try { | 4729 | try { |
3470 | // InternalProblem.g:1323:57: (iv_ruleScopeDeclaration= ruleScopeDeclaration EOF ) | 4730 | // InternalProblem.g:1735:57: (iv_ruleScopeDeclaration= ruleScopeDeclaration EOF ) |
3471 | // InternalProblem.g:1324:2: iv_ruleScopeDeclaration= ruleScopeDeclaration EOF | 4731 | // InternalProblem.g:1736:2: iv_ruleScopeDeclaration= ruleScopeDeclaration EOF |
3472 | { | 4732 | { |
3473 | newCompositeNode(grammarAccess.getScopeDeclarationRule()); | 4733 | newCompositeNode(grammarAccess.getScopeDeclarationRule()); |
3474 | pushFollow(FOLLOW_1); | 4734 | pushFollow(FOLLOW_1); |
@@ -3495,7 +4755,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3495 | 4755 | ||
3496 | 4756 | ||
3497 | // $ANTLR start "ruleScopeDeclaration" | 4757 | // $ANTLR start "ruleScopeDeclaration" |
3498 | // InternalProblem.g:1330:1: ruleScopeDeclaration returns [EObject current=null] : (otherlv_0= 'scope' ( (lv_typeScopes_1_0= ruleTypeScope ) ) (otherlv_2= ',' ( (lv_typeScopes_3_0= ruleTypeScope ) ) )* otherlv_4= '.' ) ; | 4758 | // InternalProblem.g:1742:1: ruleScopeDeclaration returns [EObject current=null] : (otherlv_0= 'scope' ( (lv_typeScopes_1_0= ruleTypeScope ) ) (otherlv_2= ',' ( (lv_typeScopes_3_0= ruleTypeScope ) ) )* otherlv_4= '.' ) ; |
3499 | public final EObject ruleScopeDeclaration() throws RecognitionException { | 4759 | public final EObject ruleScopeDeclaration() throws RecognitionException { |
3500 | EObject current = null; | 4760 | EObject current = null; |
3501 | 4761 | ||
@@ -3511,26 +4771,26 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3511 | enterRule(); | 4771 | enterRule(); |
3512 | 4772 | ||
3513 | try { | 4773 | try { |
3514 | // InternalProblem.g:1336:2: ( (otherlv_0= 'scope' ( (lv_typeScopes_1_0= ruleTypeScope ) ) (otherlv_2= ',' ( (lv_typeScopes_3_0= ruleTypeScope ) ) )* otherlv_4= '.' ) ) | 4774 | // InternalProblem.g:1748:2: ( (otherlv_0= 'scope' ( (lv_typeScopes_1_0= ruleTypeScope ) ) (otherlv_2= ',' ( (lv_typeScopes_3_0= ruleTypeScope ) ) )* otherlv_4= '.' ) ) |
3515 | // InternalProblem.g:1337:2: (otherlv_0= 'scope' ( (lv_typeScopes_1_0= ruleTypeScope ) ) (otherlv_2= ',' ( (lv_typeScopes_3_0= ruleTypeScope ) ) )* otherlv_4= '.' ) | 4775 | // InternalProblem.g:1749:2: (otherlv_0= 'scope' ( (lv_typeScopes_1_0= ruleTypeScope ) ) (otherlv_2= ',' ( (lv_typeScopes_3_0= ruleTypeScope ) ) )* otherlv_4= '.' ) |
3516 | { | 4776 | { |
3517 | // InternalProblem.g:1337:2: (otherlv_0= 'scope' ( (lv_typeScopes_1_0= ruleTypeScope ) ) (otherlv_2= ',' ( (lv_typeScopes_3_0= ruleTypeScope ) ) )* otherlv_4= '.' ) | 4777 | // InternalProblem.g:1749:2: (otherlv_0= 'scope' ( (lv_typeScopes_1_0= ruleTypeScope ) ) (otherlv_2= ',' ( (lv_typeScopes_3_0= ruleTypeScope ) ) )* otherlv_4= '.' ) |
3518 | // InternalProblem.g:1338:3: otherlv_0= 'scope' ( (lv_typeScopes_1_0= ruleTypeScope ) ) (otherlv_2= ',' ( (lv_typeScopes_3_0= ruleTypeScope ) ) )* otherlv_4= '.' | 4778 | // InternalProblem.g:1750:3: otherlv_0= 'scope' ( (lv_typeScopes_1_0= ruleTypeScope ) ) (otherlv_2= ',' ( (lv_typeScopes_3_0= ruleTypeScope ) ) )* otherlv_4= '.' |
3519 | { | 4779 | { |
3520 | otherlv_0=(Token)match(input,35,FOLLOW_31); | 4780 | otherlv_0=(Token)match(input,35,FOLLOW_33); |
3521 | 4781 | ||
3522 | newLeafNode(otherlv_0, grammarAccess.getScopeDeclarationAccess().getScopeKeyword_0()); | 4782 | newLeafNode(otherlv_0, grammarAccess.getScopeDeclarationAccess().getScopeKeyword_0()); |
3523 | 4783 | ||
3524 | // InternalProblem.g:1342:3: ( (lv_typeScopes_1_0= ruleTypeScope ) ) | 4784 | // InternalProblem.g:1754:3: ( (lv_typeScopes_1_0= ruleTypeScope ) ) |
3525 | // InternalProblem.g:1343:4: (lv_typeScopes_1_0= ruleTypeScope ) | 4785 | // InternalProblem.g:1755:4: (lv_typeScopes_1_0= ruleTypeScope ) |
3526 | { | 4786 | { |
3527 | // InternalProblem.g:1343:4: (lv_typeScopes_1_0= ruleTypeScope ) | 4787 | // InternalProblem.g:1755:4: (lv_typeScopes_1_0= ruleTypeScope ) |
3528 | // InternalProblem.g:1344:5: lv_typeScopes_1_0= ruleTypeScope | 4788 | // InternalProblem.g:1756:5: lv_typeScopes_1_0= ruleTypeScope |
3529 | { | 4789 | { |
3530 | 4790 | ||
3531 | newCompositeNode(grammarAccess.getScopeDeclarationAccess().getTypeScopesTypeScopeParserRuleCall_1_0()); | 4791 | newCompositeNode(grammarAccess.getScopeDeclarationAccess().getTypeScopesTypeScopeParserRuleCall_1_0()); |
3532 | 4792 | ||
3533 | pushFollow(FOLLOW_32); | 4793 | pushFollow(FOLLOW_34); |
3534 | lv_typeScopes_1_0=ruleTypeScope(); | 4794 | lv_typeScopes_1_0=ruleTypeScope(); |
3535 | 4795 | ||
3536 | state._fsp--; | 4796 | state._fsp--; |
@@ -3552,35 +4812,35 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3552 | 4812 | ||
3553 | } | 4813 | } |
3554 | 4814 | ||
3555 | // InternalProblem.g:1361:3: (otherlv_2= ',' ( (lv_typeScopes_3_0= ruleTypeScope ) ) )* | 4815 | // InternalProblem.g:1773:3: (otherlv_2= ',' ( (lv_typeScopes_3_0= ruleTypeScope ) ) )* |
3556 | loop35: | 4816 | loop38: |
3557 | do { | 4817 | do { |
3558 | int alt35=2; | 4818 | int alt38=2; |
3559 | int LA35_0 = input.LA(1); | 4819 | int LA38_0 = input.LA(1); |
3560 | 4820 | ||
3561 | if ( (LA35_0==17) ) { | 4821 | if ( (LA38_0==17) ) { |
3562 | alt35=1; | 4822 | alt38=1; |
3563 | } | 4823 | } |
3564 | 4824 | ||
3565 | 4825 | ||
3566 | switch (alt35) { | 4826 | switch (alt38) { |
3567 | case 1 : | 4827 | case 1 : |
3568 | // InternalProblem.g:1362:4: otherlv_2= ',' ( (lv_typeScopes_3_0= ruleTypeScope ) ) | 4828 | // InternalProblem.g:1774:4: otherlv_2= ',' ( (lv_typeScopes_3_0= ruleTypeScope ) ) |
3569 | { | 4829 | { |
3570 | otherlv_2=(Token)match(input,17,FOLLOW_31); | 4830 | otherlv_2=(Token)match(input,17,FOLLOW_33); |
3571 | 4831 | ||
3572 | newLeafNode(otherlv_2, grammarAccess.getScopeDeclarationAccess().getCommaKeyword_2_0()); | 4832 | newLeafNode(otherlv_2, grammarAccess.getScopeDeclarationAccess().getCommaKeyword_2_0()); |
3573 | 4833 | ||
3574 | // InternalProblem.g:1366:4: ( (lv_typeScopes_3_0= ruleTypeScope ) ) | 4834 | // InternalProblem.g:1778:4: ( (lv_typeScopes_3_0= ruleTypeScope ) ) |
3575 | // InternalProblem.g:1367:5: (lv_typeScopes_3_0= ruleTypeScope ) | 4835 | // InternalProblem.g:1779:5: (lv_typeScopes_3_0= ruleTypeScope ) |
3576 | { | 4836 | { |
3577 | // InternalProblem.g:1367:5: (lv_typeScopes_3_0= ruleTypeScope ) | 4837 | // InternalProblem.g:1779:5: (lv_typeScopes_3_0= ruleTypeScope ) |
3578 | // InternalProblem.g:1368:6: lv_typeScopes_3_0= ruleTypeScope | 4838 | // InternalProblem.g:1780:6: lv_typeScopes_3_0= ruleTypeScope |
3579 | { | 4839 | { |
3580 | 4840 | ||
3581 | newCompositeNode(grammarAccess.getScopeDeclarationAccess().getTypeScopesTypeScopeParserRuleCall_2_1_0()); | 4841 | newCompositeNode(grammarAccess.getScopeDeclarationAccess().getTypeScopesTypeScopeParserRuleCall_2_1_0()); |
3582 | 4842 | ||
3583 | pushFollow(FOLLOW_32); | 4843 | pushFollow(FOLLOW_34); |
3584 | lv_typeScopes_3_0=ruleTypeScope(); | 4844 | lv_typeScopes_3_0=ruleTypeScope(); |
3585 | 4845 | ||
3586 | state._fsp--; | 4846 | state._fsp--; |
@@ -3607,7 +4867,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3607 | break; | 4867 | break; |
3608 | 4868 | ||
3609 | default : | 4869 | default : |
3610 | break loop35; | 4870 | break loop38; |
3611 | } | 4871 | } |
3612 | } while (true); | 4872 | } while (true); |
3613 | 4873 | ||
@@ -3638,7 +4898,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3638 | 4898 | ||
3639 | 4899 | ||
3640 | // $ANTLR start "entryRuleTypeScope" | 4900 | // $ANTLR start "entryRuleTypeScope" |
3641 | // InternalProblem.g:1394:1: entryRuleTypeScope returns [EObject current=null] : iv_ruleTypeScope= ruleTypeScope EOF ; | 4901 | // InternalProblem.g:1806:1: entryRuleTypeScope returns [EObject current=null] : iv_ruleTypeScope= ruleTypeScope EOF ; |
3642 | public final EObject entryRuleTypeScope() throws RecognitionException { | 4902 | public final EObject entryRuleTypeScope() throws RecognitionException { |
3643 | EObject current = null; | 4903 | EObject current = null; |
3644 | 4904 | ||
@@ -3646,8 +4906,8 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3646 | 4906 | ||
3647 | 4907 | ||
3648 | try { | 4908 | try { |
3649 | // InternalProblem.g:1394:50: (iv_ruleTypeScope= ruleTypeScope EOF ) | 4909 | // InternalProblem.g:1806:50: (iv_ruleTypeScope= ruleTypeScope EOF ) |
3650 | // InternalProblem.g:1395:2: iv_ruleTypeScope= ruleTypeScope EOF | 4910 | // InternalProblem.g:1807:2: iv_ruleTypeScope= ruleTypeScope EOF |
3651 | { | 4911 | { |
3652 | newCompositeNode(grammarAccess.getTypeScopeRule()); | 4912 | newCompositeNode(grammarAccess.getTypeScopeRule()); |
3653 | pushFollow(FOLLOW_1); | 4913 | pushFollow(FOLLOW_1); |
@@ -3674,7 +4934,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3674 | 4934 | ||
3675 | 4935 | ||
3676 | // $ANTLR start "ruleTypeScope" | 4936 | // $ANTLR start "ruleTypeScope" |
3677 | // InternalProblem.g:1401:1: ruleTypeScope returns [EObject current=null] : ( ( (otherlv_0= RULE_ID ) ) ( ( (lv_increment_1_0= '+=' ) ) | otherlv_2= '=' ) ( (lv_multiplicity_3_0= ruleDefiniteMultiplicity ) ) ) ; | 4937 | // InternalProblem.g:1813:1: ruleTypeScope returns [EObject current=null] : ( ( (otherlv_0= RULE_ID ) ) ( ( (lv_increment_1_0= '+=' ) ) | otherlv_2= '=' ) ( (lv_multiplicity_3_0= ruleDefiniteMultiplicity ) ) ) ; |
3678 | public final EObject ruleTypeScope() throws RecognitionException { | 4938 | public final EObject ruleTypeScope() throws RecognitionException { |
3679 | EObject current = null; | 4939 | EObject current = null; |
3680 | 4940 | ||
@@ -3688,24 +4948,24 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3688 | enterRule(); | 4948 | enterRule(); |
3689 | 4949 | ||
3690 | try { | 4950 | try { |
3691 | // InternalProblem.g:1407:2: ( ( ( (otherlv_0= RULE_ID ) ) ( ( (lv_increment_1_0= '+=' ) ) | otherlv_2= '=' ) ( (lv_multiplicity_3_0= ruleDefiniteMultiplicity ) ) ) ) | 4951 | // InternalProblem.g:1819:2: ( ( ( (otherlv_0= RULE_ID ) ) ( ( (lv_increment_1_0= '+=' ) ) | otherlv_2= '=' ) ( (lv_multiplicity_3_0= ruleDefiniteMultiplicity ) ) ) ) |
3692 | // InternalProblem.g:1408:2: ( ( (otherlv_0= RULE_ID ) ) ( ( (lv_increment_1_0= '+=' ) ) | otherlv_2= '=' ) ( (lv_multiplicity_3_0= ruleDefiniteMultiplicity ) ) ) | 4952 | // InternalProblem.g:1820:2: ( ( (otherlv_0= RULE_ID ) ) ( ( (lv_increment_1_0= '+=' ) ) | otherlv_2= '=' ) ( (lv_multiplicity_3_0= ruleDefiniteMultiplicity ) ) ) |
3693 | { | 4953 | { |
3694 | // InternalProblem.g:1408:2: ( ( (otherlv_0= RULE_ID ) ) ( ( (lv_increment_1_0= '+=' ) ) | otherlv_2= '=' ) ( (lv_multiplicity_3_0= ruleDefiniteMultiplicity ) ) ) | 4954 | // InternalProblem.g:1820:2: ( ( (otherlv_0= RULE_ID ) ) ( ( (lv_increment_1_0= '+=' ) ) | otherlv_2= '=' ) ( (lv_multiplicity_3_0= ruleDefiniteMultiplicity ) ) ) |
3695 | // InternalProblem.g:1409:3: ( (otherlv_0= RULE_ID ) ) ( ( (lv_increment_1_0= '+=' ) ) | otherlv_2= '=' ) ( (lv_multiplicity_3_0= ruleDefiniteMultiplicity ) ) | 4955 | // InternalProblem.g:1821:3: ( (otherlv_0= RULE_ID ) ) ( ( (lv_increment_1_0= '+=' ) ) | otherlv_2= '=' ) ( (lv_multiplicity_3_0= ruleDefiniteMultiplicity ) ) |
3696 | { | 4956 | { |
3697 | // InternalProblem.g:1409:3: ( (otherlv_0= RULE_ID ) ) | 4957 | // InternalProblem.g:1821:3: ( (otherlv_0= RULE_ID ) ) |
3698 | // InternalProblem.g:1410:4: (otherlv_0= RULE_ID ) | 4958 | // InternalProblem.g:1822:4: (otherlv_0= RULE_ID ) |
3699 | { | 4959 | { |
3700 | // InternalProblem.g:1410:4: (otherlv_0= RULE_ID ) | 4960 | // InternalProblem.g:1822:4: (otherlv_0= RULE_ID ) |
3701 | // InternalProblem.g:1411:5: otherlv_0= RULE_ID | 4961 | // InternalProblem.g:1823:5: otherlv_0= RULE_ID |
3702 | { | 4962 | { |
3703 | 4963 | ||
3704 | if (current==null) { | 4964 | if (current==null) { |
3705 | current = createModelElement(grammarAccess.getTypeScopeRule()); | 4965 | current = createModelElement(grammarAccess.getTypeScopeRule()); |
3706 | } | 4966 | } |
3707 | 4967 | ||
3708 | otherlv_0=(Token)match(input,RULE_ID,FOLLOW_33); | 4968 | otherlv_0=(Token)match(input,RULE_ID,FOLLOW_35); |
3709 | 4969 | ||
3710 | newLeafNode(otherlv_0, grammarAccess.getTypeScopeAccess().getTargetTypeClassDeclarationCrossReference_0_0()); | 4970 | newLeafNode(otherlv_0, grammarAccess.getTypeScopeAccess().getTargetTypeClassDeclarationCrossReference_0_0()); |
3711 | 4971 | ||
@@ -3715,31 +4975,31 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3715 | 4975 | ||
3716 | } | 4976 | } |
3717 | 4977 | ||
3718 | // InternalProblem.g:1422:3: ( ( (lv_increment_1_0= '+=' ) ) | otherlv_2= '=' ) | 4978 | // InternalProblem.g:1834:3: ( ( (lv_increment_1_0= '+=' ) ) | otherlv_2= '=' ) |
3719 | int alt36=2; | 4979 | int alt39=2; |
3720 | int LA36_0 = input.LA(1); | 4980 | int LA39_0 = input.LA(1); |
3721 | 4981 | ||
3722 | if ( (LA36_0==36) ) { | 4982 | if ( (LA39_0==36) ) { |
3723 | alt36=1; | 4983 | alt39=1; |
3724 | } | 4984 | } |
3725 | else if ( (LA36_0==37) ) { | 4985 | else if ( (LA39_0==37) ) { |
3726 | alt36=2; | 4986 | alt39=2; |
3727 | } | 4987 | } |
3728 | else { | 4988 | else { |
3729 | NoViableAltException nvae = | 4989 | NoViableAltException nvae = |
3730 | new NoViableAltException("", 36, 0, input); | 4990 | new NoViableAltException("", 39, 0, input); |
3731 | 4991 | ||
3732 | throw nvae; | 4992 | throw nvae; |
3733 | } | 4993 | } |
3734 | switch (alt36) { | 4994 | switch (alt39) { |
3735 | case 1 : | 4995 | case 1 : |
3736 | // InternalProblem.g:1423:4: ( (lv_increment_1_0= '+=' ) ) | 4996 | // InternalProblem.g:1835:4: ( (lv_increment_1_0= '+=' ) ) |
3737 | { | 4997 | { |
3738 | // InternalProblem.g:1423:4: ( (lv_increment_1_0= '+=' ) ) | 4998 | // InternalProblem.g:1835:4: ( (lv_increment_1_0= '+=' ) ) |
3739 | // InternalProblem.g:1424:5: (lv_increment_1_0= '+=' ) | 4999 | // InternalProblem.g:1836:5: (lv_increment_1_0= '+=' ) |
3740 | { | 5000 | { |
3741 | // InternalProblem.g:1424:5: (lv_increment_1_0= '+=' ) | 5001 | // InternalProblem.g:1836:5: (lv_increment_1_0= '+=' ) |
3742 | // InternalProblem.g:1425:6: lv_increment_1_0= '+=' | 5002 | // InternalProblem.g:1837:6: lv_increment_1_0= '+=' |
3743 | { | 5003 | { |
3744 | lv_increment_1_0=(Token)match(input,36,FOLLOW_17); | 5004 | lv_increment_1_0=(Token)match(input,36,FOLLOW_17); |
3745 | 5005 | ||
@@ -3761,7 +5021,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3761 | } | 5021 | } |
3762 | break; | 5022 | break; |
3763 | case 2 : | 5023 | case 2 : |
3764 | // InternalProblem.g:1438:4: otherlv_2= '=' | 5024 | // InternalProblem.g:1850:4: otherlv_2= '=' |
3765 | { | 5025 | { |
3766 | otherlv_2=(Token)match(input,37,FOLLOW_17); | 5026 | otherlv_2=(Token)match(input,37,FOLLOW_17); |
3767 | 5027 | ||
@@ -3773,11 +5033,11 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3773 | 5033 | ||
3774 | } | 5034 | } |
3775 | 5035 | ||
3776 | // InternalProblem.g:1443:3: ( (lv_multiplicity_3_0= ruleDefiniteMultiplicity ) ) | 5036 | // InternalProblem.g:1855:3: ( (lv_multiplicity_3_0= ruleDefiniteMultiplicity ) ) |
3777 | // InternalProblem.g:1444:4: (lv_multiplicity_3_0= ruleDefiniteMultiplicity ) | 5037 | // InternalProblem.g:1856:4: (lv_multiplicity_3_0= ruleDefiniteMultiplicity ) |
3778 | { | 5038 | { |
3779 | // InternalProblem.g:1444:4: (lv_multiplicity_3_0= ruleDefiniteMultiplicity ) | 5039 | // InternalProblem.g:1856:4: (lv_multiplicity_3_0= ruleDefiniteMultiplicity ) |
3780 | // InternalProblem.g:1445:5: lv_multiplicity_3_0= ruleDefiniteMultiplicity | 5040 | // InternalProblem.g:1857:5: lv_multiplicity_3_0= ruleDefiniteMultiplicity |
3781 | { | 5041 | { |
3782 | 5042 | ||
3783 | newCompositeNode(grammarAccess.getTypeScopeAccess().getMultiplicityDefiniteMultiplicityParserRuleCall_2_0()); | 5043 | newCompositeNode(grammarAccess.getTypeScopeAccess().getMultiplicityDefiniteMultiplicityParserRuleCall_2_0()); |
@@ -3827,7 +5087,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3827 | 5087 | ||
3828 | 5088 | ||
3829 | // $ANTLR start "entryRuleMultiplicity" | 5089 | // $ANTLR start "entryRuleMultiplicity" |
3830 | // InternalProblem.g:1466:1: entryRuleMultiplicity returns [EObject current=null] : iv_ruleMultiplicity= ruleMultiplicity EOF ; | 5090 | // InternalProblem.g:1878:1: entryRuleMultiplicity returns [EObject current=null] : iv_ruleMultiplicity= ruleMultiplicity EOF ; |
3831 | public final EObject entryRuleMultiplicity() throws RecognitionException { | 5091 | public final EObject entryRuleMultiplicity() throws RecognitionException { |
3832 | EObject current = null; | 5092 | EObject current = null; |
3833 | 5093 | ||
@@ -3835,8 +5095,8 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3835 | 5095 | ||
3836 | 5096 | ||
3837 | try { | 5097 | try { |
3838 | // InternalProblem.g:1466:53: (iv_ruleMultiplicity= ruleMultiplicity EOF ) | 5098 | // InternalProblem.g:1878:53: (iv_ruleMultiplicity= ruleMultiplicity EOF ) |
3839 | // InternalProblem.g:1467:2: iv_ruleMultiplicity= ruleMultiplicity EOF | 5099 | // InternalProblem.g:1879:2: iv_ruleMultiplicity= ruleMultiplicity EOF |
3840 | { | 5100 | { |
3841 | newCompositeNode(grammarAccess.getMultiplicityRule()); | 5101 | newCompositeNode(grammarAccess.getMultiplicityRule()); |
3842 | pushFollow(FOLLOW_1); | 5102 | pushFollow(FOLLOW_1); |
@@ -3863,7 +5123,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3863 | 5123 | ||
3864 | 5124 | ||
3865 | // $ANTLR start "ruleMultiplicity" | 5125 | // $ANTLR start "ruleMultiplicity" |
3866 | // InternalProblem.g:1473:1: ruleMultiplicity returns [EObject current=null] : (this_UnboundedMultiplicity_0= ruleUnboundedMultiplicity | this_DefiniteMultiplicity_1= ruleDefiniteMultiplicity ) ; | 5126 | // InternalProblem.g:1885:1: ruleMultiplicity returns [EObject current=null] : (this_UnboundedMultiplicity_0= ruleUnboundedMultiplicity | this_DefiniteMultiplicity_1= ruleDefiniteMultiplicity ) ; |
3867 | public final EObject ruleMultiplicity() throws RecognitionException { | 5127 | public final EObject ruleMultiplicity() throws RecognitionException { |
3868 | EObject current = null; | 5128 | EObject current = null; |
3869 | 5129 | ||
@@ -3876,28 +5136,28 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3876 | enterRule(); | 5136 | enterRule(); |
3877 | 5137 | ||
3878 | try { | 5138 | try { |
3879 | // InternalProblem.g:1479:2: ( (this_UnboundedMultiplicity_0= ruleUnboundedMultiplicity | this_DefiniteMultiplicity_1= ruleDefiniteMultiplicity ) ) | 5139 | // InternalProblem.g:1891:2: ( (this_UnboundedMultiplicity_0= ruleUnboundedMultiplicity | this_DefiniteMultiplicity_1= ruleDefiniteMultiplicity ) ) |
3880 | // InternalProblem.g:1480:2: (this_UnboundedMultiplicity_0= ruleUnboundedMultiplicity | this_DefiniteMultiplicity_1= ruleDefiniteMultiplicity ) | 5140 | // InternalProblem.g:1892:2: (this_UnboundedMultiplicity_0= ruleUnboundedMultiplicity | this_DefiniteMultiplicity_1= ruleDefiniteMultiplicity ) |
3881 | { | 5141 | { |
3882 | // InternalProblem.g:1480:2: (this_UnboundedMultiplicity_0= ruleUnboundedMultiplicity | this_DefiniteMultiplicity_1= ruleDefiniteMultiplicity ) | 5142 | // InternalProblem.g:1892:2: (this_UnboundedMultiplicity_0= ruleUnboundedMultiplicity | this_DefiniteMultiplicity_1= ruleDefiniteMultiplicity ) |
3883 | int alt37=2; | 5143 | int alt40=2; |
3884 | int LA37_0 = input.LA(1); | 5144 | int LA40_0 = input.LA(1); |
3885 | 5145 | ||
3886 | if ( (LA37_0==EOF||LA37_0==25) ) { | 5146 | if ( (LA40_0==EOF||LA40_0==25) ) { |
3887 | alt37=1; | 5147 | alt40=1; |
3888 | } | 5148 | } |
3889 | else if ( (LA37_0==RULE_INT) ) { | 5149 | else if ( (LA40_0==RULE_INT) ) { |
3890 | alt37=2; | 5150 | alt40=2; |
3891 | } | 5151 | } |
3892 | else { | 5152 | else { |
3893 | NoViableAltException nvae = | 5153 | NoViableAltException nvae = |
3894 | new NoViableAltException("", 37, 0, input); | 5154 | new NoViableAltException("", 40, 0, input); |
3895 | 5155 | ||
3896 | throw nvae; | 5156 | throw nvae; |
3897 | } | 5157 | } |
3898 | switch (alt37) { | 5158 | switch (alt40) { |
3899 | case 1 : | 5159 | case 1 : |
3900 | // InternalProblem.g:1481:3: this_UnboundedMultiplicity_0= ruleUnboundedMultiplicity | 5160 | // InternalProblem.g:1893:3: this_UnboundedMultiplicity_0= ruleUnboundedMultiplicity |
3901 | { | 5161 | { |
3902 | 5162 | ||
3903 | newCompositeNode(grammarAccess.getMultiplicityAccess().getUnboundedMultiplicityParserRuleCall_0()); | 5163 | newCompositeNode(grammarAccess.getMultiplicityAccess().getUnboundedMultiplicityParserRuleCall_0()); |
@@ -3915,7 +5175,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3915 | } | 5175 | } |
3916 | break; | 5176 | break; |
3917 | case 2 : | 5177 | case 2 : |
3918 | // InternalProblem.g:1490:3: this_DefiniteMultiplicity_1= ruleDefiniteMultiplicity | 5178 | // InternalProblem.g:1902:3: this_DefiniteMultiplicity_1= ruleDefiniteMultiplicity |
3919 | { | 5179 | { |
3920 | 5180 | ||
3921 | newCompositeNode(grammarAccess.getMultiplicityAccess().getDefiniteMultiplicityParserRuleCall_1()); | 5181 | newCompositeNode(grammarAccess.getMultiplicityAccess().getDefiniteMultiplicityParserRuleCall_1()); |
@@ -3955,7 +5215,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3955 | 5215 | ||
3956 | 5216 | ||
3957 | // $ANTLR start "entryRuleDefiniteMultiplicity" | 5217 | // $ANTLR start "entryRuleDefiniteMultiplicity" |
3958 | // InternalProblem.g:1502:1: entryRuleDefiniteMultiplicity returns [EObject current=null] : iv_ruleDefiniteMultiplicity= ruleDefiniteMultiplicity EOF ; | 5218 | // InternalProblem.g:1914:1: entryRuleDefiniteMultiplicity returns [EObject current=null] : iv_ruleDefiniteMultiplicity= ruleDefiniteMultiplicity EOF ; |
3959 | public final EObject entryRuleDefiniteMultiplicity() throws RecognitionException { | 5219 | public final EObject entryRuleDefiniteMultiplicity() throws RecognitionException { |
3960 | EObject current = null; | 5220 | EObject current = null; |
3961 | 5221 | ||
@@ -3963,8 +5223,8 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3963 | 5223 | ||
3964 | 5224 | ||
3965 | try { | 5225 | try { |
3966 | // InternalProblem.g:1502:61: (iv_ruleDefiniteMultiplicity= ruleDefiniteMultiplicity EOF ) | 5226 | // InternalProblem.g:1914:61: (iv_ruleDefiniteMultiplicity= ruleDefiniteMultiplicity EOF ) |
3967 | // InternalProblem.g:1503:2: iv_ruleDefiniteMultiplicity= ruleDefiniteMultiplicity EOF | 5227 | // InternalProblem.g:1915:2: iv_ruleDefiniteMultiplicity= ruleDefiniteMultiplicity EOF |
3968 | { | 5228 | { |
3969 | newCompositeNode(grammarAccess.getDefiniteMultiplicityRule()); | 5229 | newCompositeNode(grammarAccess.getDefiniteMultiplicityRule()); |
3970 | pushFollow(FOLLOW_1); | 5230 | pushFollow(FOLLOW_1); |
@@ -3991,7 +5251,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
3991 | 5251 | ||
3992 | 5252 | ||
3993 | // $ANTLR start "ruleDefiniteMultiplicity" | 5253 | // $ANTLR start "ruleDefiniteMultiplicity" |
3994 | // InternalProblem.g:1509:1: ruleDefiniteMultiplicity returns [EObject current=null] : (this_RangeMultiplicity_0= ruleRangeMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity ) ; | 5254 | // InternalProblem.g:1921:1: ruleDefiniteMultiplicity returns [EObject current=null] : (this_RangeMultiplicity_0= ruleRangeMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity ) ; |
3995 | public final EObject ruleDefiniteMultiplicity() throws RecognitionException { | 5255 | public final EObject ruleDefiniteMultiplicity() throws RecognitionException { |
3996 | EObject current = null; | 5256 | EObject current = null; |
3997 | 5257 | ||
@@ -4004,38 +5264,38 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4004 | enterRule(); | 5264 | enterRule(); |
4005 | 5265 | ||
4006 | try { | 5266 | try { |
4007 | // InternalProblem.g:1515:2: ( (this_RangeMultiplicity_0= ruleRangeMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity ) ) | 5267 | // InternalProblem.g:1927:2: ( (this_RangeMultiplicity_0= ruleRangeMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity ) ) |
4008 | // InternalProblem.g:1516:2: (this_RangeMultiplicity_0= ruleRangeMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity ) | 5268 | // InternalProblem.g:1928:2: (this_RangeMultiplicity_0= ruleRangeMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity ) |
4009 | { | 5269 | { |
4010 | // InternalProblem.g:1516:2: (this_RangeMultiplicity_0= ruleRangeMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity ) | 5270 | // InternalProblem.g:1928:2: (this_RangeMultiplicity_0= ruleRangeMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity ) |
4011 | int alt38=2; | 5271 | int alt41=2; |
4012 | int LA38_0 = input.LA(1); | 5272 | int LA41_0 = input.LA(1); |
4013 | 5273 | ||
4014 | if ( (LA38_0==RULE_INT) ) { | 5274 | if ( (LA41_0==RULE_INT) ) { |
4015 | int LA38_1 = input.LA(2); | 5275 | int LA41_1 = input.LA(2); |
4016 | 5276 | ||
4017 | if ( (LA38_1==38) ) { | 5277 | if ( (LA41_1==38) ) { |
4018 | alt38=1; | 5278 | alt41=1; |
4019 | } | 5279 | } |
4020 | else if ( (LA38_1==EOF||LA38_1==13||LA38_1==17||LA38_1==25) ) { | 5280 | else if ( (LA41_1==EOF||LA41_1==13||LA41_1==17||LA41_1==25) ) { |
4021 | alt38=2; | 5281 | alt41=2; |
4022 | } | 5282 | } |
4023 | else { | 5283 | else { |
4024 | NoViableAltException nvae = | 5284 | NoViableAltException nvae = |
4025 | new NoViableAltException("", 38, 1, input); | 5285 | new NoViableAltException("", 41, 1, input); |
4026 | 5286 | ||
4027 | throw nvae; | 5287 | throw nvae; |
4028 | } | 5288 | } |
4029 | } | 5289 | } |
4030 | else { | 5290 | else { |
4031 | NoViableAltException nvae = | 5291 | NoViableAltException nvae = |
4032 | new NoViableAltException("", 38, 0, input); | 5292 | new NoViableAltException("", 41, 0, input); |
4033 | 5293 | ||
4034 | throw nvae; | 5294 | throw nvae; |
4035 | } | 5295 | } |
4036 | switch (alt38) { | 5296 | switch (alt41) { |
4037 | case 1 : | 5297 | case 1 : |
4038 | // InternalProblem.g:1517:3: this_RangeMultiplicity_0= ruleRangeMultiplicity | 5298 | // InternalProblem.g:1929:3: this_RangeMultiplicity_0= ruleRangeMultiplicity |
4039 | { | 5299 | { |
4040 | 5300 | ||
4041 | newCompositeNode(grammarAccess.getDefiniteMultiplicityAccess().getRangeMultiplicityParserRuleCall_0()); | 5301 | newCompositeNode(grammarAccess.getDefiniteMultiplicityAccess().getRangeMultiplicityParserRuleCall_0()); |
@@ -4053,7 +5313,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4053 | } | 5313 | } |
4054 | break; | 5314 | break; |
4055 | case 2 : | 5315 | case 2 : |
4056 | // InternalProblem.g:1526:3: this_ExactMultiplicity_1= ruleExactMultiplicity | 5316 | // InternalProblem.g:1938:3: this_ExactMultiplicity_1= ruleExactMultiplicity |
4057 | { | 5317 | { |
4058 | 5318 | ||
4059 | newCompositeNode(grammarAccess.getDefiniteMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); | 5319 | newCompositeNode(grammarAccess.getDefiniteMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); |
@@ -4093,7 +5353,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4093 | 5353 | ||
4094 | 5354 | ||
4095 | // $ANTLR start "entryRuleUnboundedMultiplicity" | 5355 | // $ANTLR start "entryRuleUnboundedMultiplicity" |
4096 | // InternalProblem.g:1538:1: entryRuleUnboundedMultiplicity returns [EObject current=null] : iv_ruleUnboundedMultiplicity= ruleUnboundedMultiplicity EOF ; | 5356 | // InternalProblem.g:1950:1: entryRuleUnboundedMultiplicity returns [EObject current=null] : iv_ruleUnboundedMultiplicity= ruleUnboundedMultiplicity EOF ; |
4097 | public final EObject entryRuleUnboundedMultiplicity() throws RecognitionException { | 5357 | public final EObject entryRuleUnboundedMultiplicity() throws RecognitionException { |
4098 | EObject current = null; | 5358 | EObject current = null; |
4099 | 5359 | ||
@@ -4101,8 +5361,8 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4101 | 5361 | ||
4102 | 5362 | ||
4103 | try { | 5363 | try { |
4104 | // InternalProblem.g:1538:62: (iv_ruleUnboundedMultiplicity= ruleUnboundedMultiplicity EOF ) | 5364 | // InternalProblem.g:1950:62: (iv_ruleUnboundedMultiplicity= ruleUnboundedMultiplicity EOF ) |
4105 | // InternalProblem.g:1539:2: iv_ruleUnboundedMultiplicity= ruleUnboundedMultiplicity EOF | 5365 | // InternalProblem.g:1951:2: iv_ruleUnboundedMultiplicity= ruleUnboundedMultiplicity EOF |
4106 | { | 5366 | { |
4107 | newCompositeNode(grammarAccess.getUnboundedMultiplicityRule()); | 5367 | newCompositeNode(grammarAccess.getUnboundedMultiplicityRule()); |
4108 | pushFollow(FOLLOW_1); | 5368 | pushFollow(FOLLOW_1); |
@@ -4129,7 +5389,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4129 | 5389 | ||
4130 | 5390 | ||
4131 | // $ANTLR start "ruleUnboundedMultiplicity" | 5391 | // $ANTLR start "ruleUnboundedMultiplicity" |
4132 | // InternalProblem.g:1545:1: ruleUnboundedMultiplicity returns [EObject current=null] : () ; | 5392 | // InternalProblem.g:1957:1: ruleUnboundedMultiplicity returns [EObject current=null] : () ; |
4133 | public final EObject ruleUnboundedMultiplicity() throws RecognitionException { | 5393 | public final EObject ruleUnboundedMultiplicity() throws RecognitionException { |
4134 | EObject current = null; | 5394 | EObject current = null; |
4135 | 5395 | ||
@@ -4137,11 +5397,11 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4137 | enterRule(); | 5397 | enterRule(); |
4138 | 5398 | ||
4139 | try { | 5399 | try { |
4140 | // InternalProblem.g:1551:2: ( () ) | 5400 | // InternalProblem.g:1963:2: ( () ) |
4141 | // InternalProblem.g:1552:2: () | 5401 | // InternalProblem.g:1964:2: () |
4142 | { | 5402 | { |
4143 | // InternalProblem.g:1552:2: () | 5403 | // InternalProblem.g:1964:2: () |
4144 | // InternalProblem.g:1553:3: | 5404 | // InternalProblem.g:1965:3: |
4145 | { | 5405 | { |
4146 | 5406 | ||
4147 | current = forceCreateModelElement( | 5407 | current = forceCreateModelElement( |
@@ -4166,7 +5426,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4166 | 5426 | ||
4167 | 5427 | ||
4168 | // $ANTLR start "entryRuleRangeMultiplicity" | 5428 | // $ANTLR start "entryRuleRangeMultiplicity" |
4169 | // InternalProblem.g:1562:1: entryRuleRangeMultiplicity returns [EObject current=null] : iv_ruleRangeMultiplicity= ruleRangeMultiplicity EOF ; | 5429 | // InternalProblem.g:1974:1: entryRuleRangeMultiplicity returns [EObject current=null] : iv_ruleRangeMultiplicity= ruleRangeMultiplicity EOF ; |
4170 | public final EObject entryRuleRangeMultiplicity() throws RecognitionException { | 5430 | public final EObject entryRuleRangeMultiplicity() throws RecognitionException { |
4171 | EObject current = null; | 5431 | EObject current = null; |
4172 | 5432 | ||
@@ -4174,8 +5434,8 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4174 | 5434 | ||
4175 | 5435 | ||
4176 | try { | 5436 | try { |
4177 | // InternalProblem.g:1562:58: (iv_ruleRangeMultiplicity= ruleRangeMultiplicity EOF ) | 5437 | // InternalProblem.g:1974:58: (iv_ruleRangeMultiplicity= ruleRangeMultiplicity EOF ) |
4178 | // InternalProblem.g:1563:2: iv_ruleRangeMultiplicity= ruleRangeMultiplicity EOF | 5438 | // InternalProblem.g:1975:2: iv_ruleRangeMultiplicity= ruleRangeMultiplicity EOF |
4179 | { | 5439 | { |
4180 | newCompositeNode(grammarAccess.getRangeMultiplicityRule()); | 5440 | newCompositeNode(grammarAccess.getRangeMultiplicityRule()); |
4181 | pushFollow(FOLLOW_1); | 5441 | pushFollow(FOLLOW_1); |
@@ -4202,7 +5462,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4202 | 5462 | ||
4203 | 5463 | ||
4204 | // $ANTLR start "ruleRangeMultiplicity" | 5464 | // $ANTLR start "ruleRangeMultiplicity" |
4205 | // InternalProblem.g:1569:1: ruleRangeMultiplicity returns [EObject current=null] : ( ( (lv_lowerBound_0_0= RULE_INT ) ) otherlv_1= '..' ( (lv_upperBound_2_0= ruleUpperBound ) ) ) ; | 5465 | // InternalProblem.g:1981:1: ruleRangeMultiplicity returns [EObject current=null] : ( ( (lv_lowerBound_0_0= RULE_INT ) ) otherlv_1= '..' ( (lv_upperBound_2_0= ruleUpperBound ) ) ) ; |
4206 | public final EObject ruleRangeMultiplicity() throws RecognitionException { | 5466 | public final EObject ruleRangeMultiplicity() throws RecognitionException { |
4207 | EObject current = null; | 5467 | EObject current = null; |
4208 | 5468 | ||
@@ -4215,19 +5475,19 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4215 | enterRule(); | 5475 | enterRule(); |
4216 | 5476 | ||
4217 | try { | 5477 | try { |
4218 | // InternalProblem.g:1575:2: ( ( ( (lv_lowerBound_0_0= RULE_INT ) ) otherlv_1= '..' ( (lv_upperBound_2_0= ruleUpperBound ) ) ) ) | 5478 | // InternalProblem.g:1987:2: ( ( ( (lv_lowerBound_0_0= RULE_INT ) ) otherlv_1= '..' ( (lv_upperBound_2_0= ruleUpperBound ) ) ) ) |
4219 | // InternalProblem.g:1576:2: ( ( (lv_lowerBound_0_0= RULE_INT ) ) otherlv_1= '..' ( (lv_upperBound_2_0= ruleUpperBound ) ) ) | 5479 | // InternalProblem.g:1988:2: ( ( (lv_lowerBound_0_0= RULE_INT ) ) otherlv_1= '..' ( (lv_upperBound_2_0= ruleUpperBound ) ) ) |
4220 | { | 5480 | { |
4221 | // InternalProblem.g:1576:2: ( ( (lv_lowerBound_0_0= RULE_INT ) ) otherlv_1= '..' ( (lv_upperBound_2_0= ruleUpperBound ) ) ) | 5481 | // InternalProblem.g:1988:2: ( ( (lv_lowerBound_0_0= RULE_INT ) ) otherlv_1= '..' ( (lv_upperBound_2_0= ruleUpperBound ) ) ) |
4222 | // InternalProblem.g:1577:3: ( (lv_lowerBound_0_0= RULE_INT ) ) otherlv_1= '..' ( (lv_upperBound_2_0= ruleUpperBound ) ) | 5482 | // InternalProblem.g:1989:3: ( (lv_lowerBound_0_0= RULE_INT ) ) otherlv_1= '..' ( (lv_upperBound_2_0= ruleUpperBound ) ) |
4223 | { | 5483 | { |
4224 | // InternalProblem.g:1577:3: ( (lv_lowerBound_0_0= RULE_INT ) ) | 5484 | // InternalProblem.g:1989:3: ( (lv_lowerBound_0_0= RULE_INT ) ) |
4225 | // InternalProblem.g:1578:4: (lv_lowerBound_0_0= RULE_INT ) | 5485 | // InternalProblem.g:1990:4: (lv_lowerBound_0_0= RULE_INT ) |
4226 | { | 5486 | { |
4227 | // InternalProblem.g:1578:4: (lv_lowerBound_0_0= RULE_INT ) | 5487 | // InternalProblem.g:1990:4: (lv_lowerBound_0_0= RULE_INT ) |
4228 | // InternalProblem.g:1579:5: lv_lowerBound_0_0= RULE_INT | 5488 | // InternalProblem.g:1991:5: lv_lowerBound_0_0= RULE_INT |
4229 | { | 5489 | { |
4230 | lv_lowerBound_0_0=(Token)match(input,RULE_INT,FOLLOW_34); | 5490 | lv_lowerBound_0_0=(Token)match(input,RULE_INT,FOLLOW_36); |
4231 | 5491 | ||
4232 | newLeafNode(lv_lowerBound_0_0, grammarAccess.getRangeMultiplicityAccess().getLowerBoundINTTerminalRuleCall_0_0()); | 5492 | newLeafNode(lv_lowerBound_0_0, grammarAccess.getRangeMultiplicityAccess().getLowerBoundINTTerminalRuleCall_0_0()); |
4233 | 5493 | ||
@@ -4247,15 +5507,15 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4247 | 5507 | ||
4248 | } | 5508 | } |
4249 | 5509 | ||
4250 | otherlv_1=(Token)match(input,38,FOLLOW_35); | 5510 | otherlv_1=(Token)match(input,38,FOLLOW_37); |
4251 | 5511 | ||
4252 | newLeafNode(otherlv_1, grammarAccess.getRangeMultiplicityAccess().getFullStopFullStopKeyword_1()); | 5512 | newLeafNode(otherlv_1, grammarAccess.getRangeMultiplicityAccess().getFullStopFullStopKeyword_1()); |
4253 | 5513 | ||
4254 | // InternalProblem.g:1599:3: ( (lv_upperBound_2_0= ruleUpperBound ) ) | 5514 | // InternalProblem.g:2011:3: ( (lv_upperBound_2_0= ruleUpperBound ) ) |
4255 | // InternalProblem.g:1600:4: (lv_upperBound_2_0= ruleUpperBound ) | 5515 | // InternalProblem.g:2012:4: (lv_upperBound_2_0= ruleUpperBound ) |
4256 | { | 5516 | { |
4257 | // InternalProblem.g:1600:4: (lv_upperBound_2_0= ruleUpperBound ) | 5517 | // InternalProblem.g:2012:4: (lv_upperBound_2_0= ruleUpperBound ) |
4258 | // InternalProblem.g:1601:5: lv_upperBound_2_0= ruleUpperBound | 5518 | // InternalProblem.g:2013:5: lv_upperBound_2_0= ruleUpperBound |
4259 | { | 5519 | { |
4260 | 5520 | ||
4261 | newCompositeNode(grammarAccess.getRangeMultiplicityAccess().getUpperBoundUpperBoundParserRuleCall_2_0()); | 5521 | newCompositeNode(grammarAccess.getRangeMultiplicityAccess().getUpperBoundUpperBoundParserRuleCall_2_0()); |
@@ -4305,7 +5565,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4305 | 5565 | ||
4306 | 5566 | ||
4307 | // $ANTLR start "entryRuleExactMultiplicity" | 5567 | // $ANTLR start "entryRuleExactMultiplicity" |
4308 | // InternalProblem.g:1622:1: entryRuleExactMultiplicity returns [EObject current=null] : iv_ruleExactMultiplicity= ruleExactMultiplicity EOF ; | 5568 | // InternalProblem.g:2034:1: entryRuleExactMultiplicity returns [EObject current=null] : iv_ruleExactMultiplicity= ruleExactMultiplicity EOF ; |
4309 | public final EObject entryRuleExactMultiplicity() throws RecognitionException { | 5569 | public final EObject entryRuleExactMultiplicity() throws RecognitionException { |
4310 | EObject current = null; | 5570 | EObject current = null; |
4311 | 5571 | ||
@@ -4313,8 +5573,8 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4313 | 5573 | ||
4314 | 5574 | ||
4315 | try { | 5575 | try { |
4316 | // InternalProblem.g:1622:58: (iv_ruleExactMultiplicity= ruleExactMultiplicity EOF ) | 5576 | // InternalProblem.g:2034:58: (iv_ruleExactMultiplicity= ruleExactMultiplicity EOF ) |
4317 | // InternalProblem.g:1623:2: iv_ruleExactMultiplicity= ruleExactMultiplicity EOF | 5577 | // InternalProblem.g:2035:2: iv_ruleExactMultiplicity= ruleExactMultiplicity EOF |
4318 | { | 5578 | { |
4319 | newCompositeNode(grammarAccess.getExactMultiplicityRule()); | 5579 | newCompositeNode(grammarAccess.getExactMultiplicityRule()); |
4320 | pushFollow(FOLLOW_1); | 5580 | pushFollow(FOLLOW_1); |
@@ -4341,7 +5601,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4341 | 5601 | ||
4342 | 5602 | ||
4343 | // $ANTLR start "ruleExactMultiplicity" | 5603 | // $ANTLR start "ruleExactMultiplicity" |
4344 | // InternalProblem.g:1629:1: ruleExactMultiplicity returns [EObject current=null] : ( (lv_exactValue_0_0= RULE_INT ) ) ; | 5604 | // InternalProblem.g:2041:1: ruleExactMultiplicity returns [EObject current=null] : ( (lv_exactValue_0_0= RULE_INT ) ) ; |
4345 | public final EObject ruleExactMultiplicity() throws RecognitionException { | 5605 | public final EObject ruleExactMultiplicity() throws RecognitionException { |
4346 | EObject current = null; | 5606 | EObject current = null; |
4347 | 5607 | ||
@@ -4351,14 +5611,14 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4351 | enterRule(); | 5611 | enterRule(); |
4352 | 5612 | ||
4353 | try { | 5613 | try { |
4354 | // InternalProblem.g:1635:2: ( ( (lv_exactValue_0_0= RULE_INT ) ) ) | 5614 | // InternalProblem.g:2047:2: ( ( (lv_exactValue_0_0= RULE_INT ) ) ) |
4355 | // InternalProblem.g:1636:2: ( (lv_exactValue_0_0= RULE_INT ) ) | 5615 | // InternalProblem.g:2048:2: ( (lv_exactValue_0_0= RULE_INT ) ) |
4356 | { | 5616 | { |
4357 | // InternalProblem.g:1636:2: ( (lv_exactValue_0_0= RULE_INT ) ) | 5617 | // InternalProblem.g:2048:2: ( (lv_exactValue_0_0= RULE_INT ) ) |
4358 | // InternalProblem.g:1637:3: (lv_exactValue_0_0= RULE_INT ) | 5618 | // InternalProblem.g:2049:3: (lv_exactValue_0_0= RULE_INT ) |
4359 | { | 5619 | { |
4360 | // InternalProblem.g:1637:3: (lv_exactValue_0_0= RULE_INT ) | 5620 | // InternalProblem.g:2049:3: (lv_exactValue_0_0= RULE_INT ) |
4361 | // InternalProblem.g:1638:4: lv_exactValue_0_0= RULE_INT | 5621 | // InternalProblem.g:2050:4: lv_exactValue_0_0= RULE_INT |
4362 | { | 5622 | { |
4363 | lv_exactValue_0_0=(Token)match(input,RULE_INT,FOLLOW_2); | 5623 | lv_exactValue_0_0=(Token)match(input,RULE_INT,FOLLOW_2); |
4364 | 5624 | ||
@@ -4400,7 +5660,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4400 | 5660 | ||
4401 | 5661 | ||
4402 | // $ANTLR start "entryRuleUpperBound" | 5662 | // $ANTLR start "entryRuleUpperBound" |
4403 | // InternalProblem.g:1657:1: entryRuleUpperBound returns [String current=null] : iv_ruleUpperBound= ruleUpperBound EOF ; | 5663 | // InternalProblem.g:2069:1: entryRuleUpperBound returns [String current=null] : iv_ruleUpperBound= ruleUpperBound EOF ; |
4404 | public final String entryRuleUpperBound() throws RecognitionException { | 5664 | public final String entryRuleUpperBound() throws RecognitionException { |
4405 | String current = null; | 5665 | String current = null; |
4406 | 5666 | ||
@@ -4408,8 +5668,8 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4408 | 5668 | ||
4409 | 5669 | ||
4410 | try { | 5670 | try { |
4411 | // InternalProblem.g:1657:50: (iv_ruleUpperBound= ruleUpperBound EOF ) | 5671 | // InternalProblem.g:2069:50: (iv_ruleUpperBound= ruleUpperBound EOF ) |
4412 | // InternalProblem.g:1658:2: iv_ruleUpperBound= ruleUpperBound EOF | 5672 | // InternalProblem.g:2070:2: iv_ruleUpperBound= ruleUpperBound EOF |
4413 | { | 5673 | { |
4414 | newCompositeNode(grammarAccess.getUpperBoundRule()); | 5674 | newCompositeNode(grammarAccess.getUpperBoundRule()); |
4415 | pushFollow(FOLLOW_1); | 5675 | pushFollow(FOLLOW_1); |
@@ -4436,7 +5696,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4436 | 5696 | ||
4437 | 5697 | ||
4438 | // $ANTLR start "ruleUpperBound" | 5698 | // $ANTLR start "ruleUpperBound" |
4439 | // InternalProblem.g:1664:1: ruleUpperBound returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_INT_0= RULE_INT | kw= '*' ) ; | 5699 | // InternalProblem.g:2076:1: ruleUpperBound returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_INT_0= RULE_INT | kw= '*' ) ; |
4440 | public final AntlrDatatypeRuleToken ruleUpperBound() throws RecognitionException { | 5700 | public final AntlrDatatypeRuleToken ruleUpperBound() throws RecognitionException { |
4441 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); | 5701 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); |
4442 | 5702 | ||
@@ -4447,28 +5707,28 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4447 | enterRule(); | 5707 | enterRule(); |
4448 | 5708 | ||
4449 | try { | 5709 | try { |
4450 | // InternalProblem.g:1670:2: ( (this_INT_0= RULE_INT | kw= '*' ) ) | 5710 | // InternalProblem.g:2082:2: ( (this_INT_0= RULE_INT | kw= '*' ) ) |
4451 | // InternalProblem.g:1671:2: (this_INT_0= RULE_INT | kw= '*' ) | 5711 | // InternalProblem.g:2083:2: (this_INT_0= RULE_INT | kw= '*' ) |
4452 | { | 5712 | { |
4453 | // InternalProblem.g:1671:2: (this_INT_0= RULE_INT | kw= '*' ) | 5713 | // InternalProblem.g:2083:2: (this_INT_0= RULE_INT | kw= '*' ) |
4454 | int alt39=2; | 5714 | int alt42=2; |
4455 | int LA39_0 = input.LA(1); | 5715 | int LA42_0 = input.LA(1); |
4456 | 5716 | ||
4457 | if ( (LA39_0==RULE_INT) ) { | 5717 | if ( (LA42_0==RULE_INT) ) { |
4458 | alt39=1; | 5718 | alt42=1; |
4459 | } | 5719 | } |
4460 | else if ( (LA39_0==39) ) { | 5720 | else if ( (LA42_0==39) ) { |
4461 | alt39=2; | 5721 | alt42=2; |
4462 | } | 5722 | } |
4463 | else { | 5723 | else { |
4464 | NoViableAltException nvae = | 5724 | NoViableAltException nvae = |
4465 | new NoViableAltException("", 39, 0, input); | 5725 | new NoViableAltException("", 42, 0, input); |
4466 | 5726 | ||
4467 | throw nvae; | 5727 | throw nvae; |
4468 | } | 5728 | } |
4469 | switch (alt39) { | 5729 | switch (alt42) { |
4470 | case 1 : | 5730 | case 1 : |
4471 | // InternalProblem.g:1672:3: this_INT_0= RULE_INT | 5731 | // InternalProblem.g:2084:3: this_INT_0= RULE_INT |
4472 | { | 5732 | { |
4473 | this_INT_0=(Token)match(input,RULE_INT,FOLLOW_2); | 5733 | this_INT_0=(Token)match(input,RULE_INT,FOLLOW_2); |
4474 | 5734 | ||
@@ -4481,7 +5741,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4481 | } | 5741 | } |
4482 | break; | 5742 | break; |
4483 | case 2 : | 5743 | case 2 : |
4484 | // InternalProblem.g:1680:3: kw= '*' | 5744 | // InternalProblem.g:2092:3: kw= '*' |
4485 | { | 5745 | { |
4486 | kw=(Token)match(input,39,FOLLOW_2); | 5746 | kw=(Token)match(input,39,FOLLOW_2); |
4487 | 5747 | ||
@@ -4514,7 +5774,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4514 | 5774 | ||
4515 | 5775 | ||
4516 | // $ANTLR start "entryRuleQuotedOrUnquotedId" | 5776 | // $ANTLR start "entryRuleQuotedOrUnquotedId" |
4517 | // InternalProblem.g:1689:1: entryRuleQuotedOrUnquotedId returns [String current=null] : iv_ruleQuotedOrUnquotedId= ruleQuotedOrUnquotedId EOF ; | 5777 | // InternalProblem.g:2101:1: entryRuleQuotedOrUnquotedId returns [String current=null] : iv_ruleQuotedOrUnquotedId= ruleQuotedOrUnquotedId EOF ; |
4518 | public final String entryRuleQuotedOrUnquotedId() throws RecognitionException { | 5778 | public final String entryRuleQuotedOrUnquotedId() throws RecognitionException { |
4519 | String current = null; | 5779 | String current = null; |
4520 | 5780 | ||
@@ -4522,8 +5782,8 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4522 | 5782 | ||
4523 | 5783 | ||
4524 | try { | 5784 | try { |
4525 | // InternalProblem.g:1689:58: (iv_ruleQuotedOrUnquotedId= ruleQuotedOrUnquotedId EOF ) | 5785 | // InternalProblem.g:2101:58: (iv_ruleQuotedOrUnquotedId= ruleQuotedOrUnquotedId EOF ) |
4526 | // InternalProblem.g:1690:2: iv_ruleQuotedOrUnquotedId= ruleQuotedOrUnquotedId EOF | 5786 | // InternalProblem.g:2102:2: iv_ruleQuotedOrUnquotedId= ruleQuotedOrUnquotedId EOF |
4527 | { | 5787 | { |
4528 | newCompositeNode(grammarAccess.getQuotedOrUnquotedIdRule()); | 5788 | newCompositeNode(grammarAccess.getQuotedOrUnquotedIdRule()); |
4529 | pushFollow(FOLLOW_1); | 5789 | pushFollow(FOLLOW_1); |
@@ -4550,7 +5810,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4550 | 5810 | ||
4551 | 5811 | ||
4552 | // $ANTLR start "ruleQuotedOrUnquotedId" | 5812 | // $ANTLR start "ruleQuotedOrUnquotedId" |
4553 | // InternalProblem.g:1696:1: ruleQuotedOrUnquotedId returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_QUOTED_ID_0= RULE_QUOTED_ID | this_Identifier_1= ruleIdentifier ) ; | 5813 | // InternalProblem.g:2108:1: ruleQuotedOrUnquotedId returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_QUOTED_ID_0= RULE_QUOTED_ID | this_Identifier_1= ruleIdentifier ) ; |
4554 | public final AntlrDatatypeRuleToken ruleQuotedOrUnquotedId() throws RecognitionException { | 5814 | public final AntlrDatatypeRuleToken ruleQuotedOrUnquotedId() throws RecognitionException { |
4555 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); | 5815 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); |
4556 | 5816 | ||
@@ -4562,28 +5822,28 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4562 | enterRule(); | 5822 | enterRule(); |
4563 | 5823 | ||
4564 | try { | 5824 | try { |
4565 | // InternalProblem.g:1702:2: ( (this_QUOTED_ID_0= RULE_QUOTED_ID | this_Identifier_1= ruleIdentifier ) ) | 5825 | // InternalProblem.g:2114:2: ( (this_QUOTED_ID_0= RULE_QUOTED_ID | this_Identifier_1= ruleIdentifier ) ) |
4566 | // InternalProblem.g:1703:2: (this_QUOTED_ID_0= RULE_QUOTED_ID | this_Identifier_1= ruleIdentifier ) | 5826 | // InternalProblem.g:2115:2: (this_QUOTED_ID_0= RULE_QUOTED_ID | this_Identifier_1= ruleIdentifier ) |
4567 | { | 5827 | { |
4568 | // InternalProblem.g:1703:2: (this_QUOTED_ID_0= RULE_QUOTED_ID | this_Identifier_1= ruleIdentifier ) | 5828 | // InternalProblem.g:2115:2: (this_QUOTED_ID_0= RULE_QUOTED_ID | this_Identifier_1= ruleIdentifier ) |
4569 | int alt40=2; | 5829 | int alt43=2; |
4570 | int LA40_0 = input.LA(1); | 5830 | int LA43_0 = input.LA(1); |
4571 | 5831 | ||
4572 | if ( (LA40_0==RULE_QUOTED_ID) ) { | 5832 | if ( (LA43_0==RULE_QUOTED_ID) ) { |
4573 | alt40=1; | 5833 | alt43=1; |
4574 | } | 5834 | } |
4575 | else if ( (LA40_0==RULE_ID||(LA40_0>=41 && LA40_0<=42)) ) { | 5835 | else if ( (LA43_0==RULE_ID||(LA43_0>=41 && LA43_0<=44)) ) { |
4576 | alt40=2; | 5836 | alt43=2; |
4577 | } | 5837 | } |
4578 | else { | 5838 | else { |
4579 | NoViableAltException nvae = | 5839 | NoViableAltException nvae = |
4580 | new NoViableAltException("", 40, 0, input); | 5840 | new NoViableAltException("", 43, 0, input); |
4581 | 5841 | ||
4582 | throw nvae; | 5842 | throw nvae; |
4583 | } | 5843 | } |
4584 | switch (alt40) { | 5844 | switch (alt43) { |
4585 | case 1 : | 5845 | case 1 : |
4586 | // InternalProblem.g:1704:3: this_QUOTED_ID_0= RULE_QUOTED_ID | 5846 | // InternalProblem.g:2116:3: this_QUOTED_ID_0= RULE_QUOTED_ID |
4587 | { | 5847 | { |
4588 | this_QUOTED_ID_0=(Token)match(input,RULE_QUOTED_ID,FOLLOW_2); | 5848 | this_QUOTED_ID_0=(Token)match(input,RULE_QUOTED_ID,FOLLOW_2); |
4589 | 5849 | ||
@@ -4596,7 +5856,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4596 | } | 5856 | } |
4597 | break; | 5857 | break; |
4598 | case 2 : | 5858 | case 2 : |
4599 | // InternalProblem.g:1712:3: this_Identifier_1= ruleIdentifier | 5859 | // InternalProblem.g:2124:3: this_Identifier_1= ruleIdentifier |
4600 | { | 5860 | { |
4601 | 5861 | ||
4602 | newCompositeNode(grammarAccess.getQuotedOrUnquotedIdAccess().getIdentifierParserRuleCall_1()); | 5862 | newCompositeNode(grammarAccess.getQuotedOrUnquotedIdAccess().getIdentifierParserRuleCall_1()); |
@@ -4638,16 +5898,19 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4638 | 5898 | ||
4639 | 5899 | ||
4640 | // $ANTLR start "entryRuleQualifiedName" | 5900 | // $ANTLR start "entryRuleQualifiedName" |
4641 | // InternalProblem.g:1726:1: entryRuleQualifiedName returns [String current=null] : iv_ruleQualifiedName= ruleQualifiedName EOF ; | 5901 | // InternalProblem.g:2138:1: entryRuleQualifiedName returns [String current=null] : iv_ruleQualifiedName= ruleQualifiedName EOF ; |
4642 | public final String entryRuleQualifiedName() throws RecognitionException { | 5902 | public final String entryRuleQualifiedName() throws RecognitionException { |
4643 | String current = null; | 5903 | String current = null; |
4644 | 5904 | ||
4645 | AntlrDatatypeRuleToken iv_ruleQualifiedName = null; | 5905 | AntlrDatatypeRuleToken iv_ruleQualifiedName = null; |
4646 | 5906 | ||
4647 | 5907 | ||
5908 | |||
5909 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
5910 | |||
4648 | try { | 5911 | try { |
4649 | // InternalProblem.g:1726:53: (iv_ruleQualifiedName= ruleQualifiedName EOF ) | 5912 | // InternalProblem.g:2140:2: (iv_ruleQualifiedName= ruleQualifiedName EOF ) |
4650 | // InternalProblem.g:1727:2: iv_ruleQualifiedName= ruleQualifiedName EOF | 5913 | // InternalProblem.g:2141:2: iv_ruleQualifiedName= ruleQualifiedName EOF |
4651 | { | 5914 | { |
4652 | newCompositeNode(grammarAccess.getQualifiedNameRule()); | 5915 | newCompositeNode(grammarAccess.getQualifiedNameRule()); |
4653 | pushFollow(FOLLOW_1); | 5916 | pushFollow(FOLLOW_1); |
@@ -4667,6 +5930,9 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4667 | appendSkippedTokens(); | 5930 | appendSkippedTokens(); |
4668 | } | 5931 | } |
4669 | finally { | 5932 | finally { |
5933 | |||
5934 | myHiddenTokenState.restore(); | ||
5935 | |||
4670 | } | 5936 | } |
4671 | return current; | 5937 | return current; |
4672 | } | 5938 | } |
@@ -4674,7 +5940,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4674 | 5940 | ||
4675 | 5941 | ||
4676 | // $ANTLR start "ruleQualifiedName" | 5942 | // $ANTLR start "ruleQualifiedName" |
4677 | // InternalProblem.g:1733:1: ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_QUOTED_ID_0= RULE_QUOTED_ID | (this_Identifier_1= ruleIdentifier (kw= '::' this_Identifier_3= ruleIdentifier )* (kw= '::' this_QUOTED_ID_5= RULE_QUOTED_ID )? ) ) ; | 5943 | // InternalProblem.g:2150:1: ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_QUOTED_ID_0= RULE_QUOTED_ID | (this_Identifier_1= ruleIdentifier (kw= '::' this_Identifier_3= ruleIdentifier )* (kw= '::' this_QUOTED_ID_5= RULE_QUOTED_ID )? ) ) ; |
4678 | public final AntlrDatatypeRuleToken ruleQualifiedName() throws RecognitionException { | 5944 | public final AntlrDatatypeRuleToken ruleQualifiedName() throws RecognitionException { |
4679 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); | 5945 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); |
4680 | 5946 | ||
@@ -4688,30 +5954,31 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4688 | 5954 | ||
4689 | 5955 | ||
4690 | enterRule(); | 5956 | enterRule(); |
5957 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
4691 | 5958 | ||
4692 | try { | 5959 | try { |
4693 | // InternalProblem.g:1739:2: ( (this_QUOTED_ID_0= RULE_QUOTED_ID | (this_Identifier_1= ruleIdentifier (kw= '::' this_Identifier_3= ruleIdentifier )* (kw= '::' this_QUOTED_ID_5= RULE_QUOTED_ID )? ) ) ) | 5960 | // InternalProblem.g:2157:2: ( (this_QUOTED_ID_0= RULE_QUOTED_ID | (this_Identifier_1= ruleIdentifier (kw= '::' this_Identifier_3= ruleIdentifier )* (kw= '::' this_QUOTED_ID_5= RULE_QUOTED_ID )? ) ) ) |
4694 | // InternalProblem.g:1740:2: (this_QUOTED_ID_0= RULE_QUOTED_ID | (this_Identifier_1= ruleIdentifier (kw= '::' this_Identifier_3= ruleIdentifier )* (kw= '::' this_QUOTED_ID_5= RULE_QUOTED_ID )? ) ) | 5961 | // InternalProblem.g:2158:2: (this_QUOTED_ID_0= RULE_QUOTED_ID | (this_Identifier_1= ruleIdentifier (kw= '::' this_Identifier_3= ruleIdentifier )* (kw= '::' this_QUOTED_ID_5= RULE_QUOTED_ID )? ) ) |
4695 | { | 5962 | { |
4696 | // InternalProblem.g:1740:2: (this_QUOTED_ID_0= RULE_QUOTED_ID | (this_Identifier_1= ruleIdentifier (kw= '::' this_Identifier_3= ruleIdentifier )* (kw= '::' this_QUOTED_ID_5= RULE_QUOTED_ID )? ) ) | 5963 | // InternalProblem.g:2158:2: (this_QUOTED_ID_0= RULE_QUOTED_ID | (this_Identifier_1= ruleIdentifier (kw= '::' this_Identifier_3= ruleIdentifier )* (kw= '::' this_QUOTED_ID_5= RULE_QUOTED_ID )? ) ) |
4697 | int alt43=2; | 5964 | int alt46=2; |
4698 | int LA43_0 = input.LA(1); | 5965 | int LA46_0 = input.LA(1); |
4699 | 5966 | ||
4700 | if ( (LA43_0==RULE_QUOTED_ID) ) { | 5967 | if ( (LA46_0==RULE_QUOTED_ID) ) { |
4701 | alt43=1; | 5968 | alt46=1; |
4702 | } | 5969 | } |
4703 | else if ( (LA43_0==RULE_ID||(LA43_0>=41 && LA43_0<=42)) ) { | 5970 | else if ( (LA46_0==RULE_ID||(LA46_0>=41 && LA46_0<=44)) ) { |
4704 | alt43=2; | 5971 | alt46=2; |
4705 | } | 5972 | } |
4706 | else { | 5973 | else { |
4707 | NoViableAltException nvae = | 5974 | NoViableAltException nvae = |
4708 | new NoViableAltException("", 43, 0, input); | 5975 | new NoViableAltException("", 46, 0, input); |
4709 | 5976 | ||
4710 | throw nvae; | 5977 | throw nvae; |
4711 | } | 5978 | } |
4712 | switch (alt43) { | 5979 | switch (alt46) { |
4713 | case 1 : | 5980 | case 1 : |
4714 | // InternalProblem.g:1741:3: this_QUOTED_ID_0= RULE_QUOTED_ID | 5981 | // InternalProblem.g:2159:3: this_QUOTED_ID_0= RULE_QUOTED_ID |
4715 | { | 5982 | { |
4716 | this_QUOTED_ID_0=(Token)match(input,RULE_QUOTED_ID,FOLLOW_2); | 5983 | this_QUOTED_ID_0=(Token)match(input,RULE_QUOTED_ID,FOLLOW_2); |
4717 | 5984 | ||
@@ -4724,15 +5991,15 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4724 | } | 5991 | } |
4725 | break; | 5992 | break; |
4726 | case 2 : | 5993 | case 2 : |
4727 | // InternalProblem.g:1749:3: (this_Identifier_1= ruleIdentifier (kw= '::' this_Identifier_3= ruleIdentifier )* (kw= '::' this_QUOTED_ID_5= RULE_QUOTED_ID )? ) | 5994 | // InternalProblem.g:2167:3: (this_Identifier_1= ruleIdentifier (kw= '::' this_Identifier_3= ruleIdentifier )* (kw= '::' this_QUOTED_ID_5= RULE_QUOTED_ID )? ) |
4728 | { | 5995 | { |
4729 | // InternalProblem.g:1749:3: (this_Identifier_1= ruleIdentifier (kw= '::' this_Identifier_3= ruleIdentifier )* (kw= '::' this_QUOTED_ID_5= RULE_QUOTED_ID )? ) | 5996 | // InternalProblem.g:2167:3: (this_Identifier_1= ruleIdentifier (kw= '::' this_Identifier_3= ruleIdentifier )* (kw= '::' this_QUOTED_ID_5= RULE_QUOTED_ID )? ) |
4730 | // InternalProblem.g:1750:4: this_Identifier_1= ruleIdentifier (kw= '::' this_Identifier_3= ruleIdentifier )* (kw= '::' this_QUOTED_ID_5= RULE_QUOTED_ID )? | 5997 | // InternalProblem.g:2168:4: this_Identifier_1= ruleIdentifier (kw= '::' this_Identifier_3= ruleIdentifier )* (kw= '::' this_QUOTED_ID_5= RULE_QUOTED_ID )? |
4731 | { | 5998 | { |
4732 | 5999 | ||
4733 | newCompositeNode(grammarAccess.getQualifiedNameAccess().getIdentifierParserRuleCall_1_0()); | 6000 | newCompositeNode(grammarAccess.getQualifiedNameAccess().getIdentifierParserRuleCall_1_0()); |
4734 | 6001 | ||
4735 | pushFollow(FOLLOW_36); | 6002 | pushFollow(FOLLOW_38); |
4736 | this_Identifier_1=ruleIdentifier(); | 6003 | this_Identifier_1=ruleIdentifier(); |
4737 | 6004 | ||
4738 | state._fsp--; | 6005 | state._fsp--; |
@@ -4743,26 +6010,26 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4743 | 6010 | ||
4744 | afterParserOrEnumRuleCall(); | 6011 | afterParserOrEnumRuleCall(); |
4745 | 6012 | ||
4746 | // InternalProblem.g:1760:4: (kw= '::' this_Identifier_3= ruleIdentifier )* | 6013 | // InternalProblem.g:2178:4: (kw= '::' this_Identifier_3= ruleIdentifier )* |
4747 | loop41: | 6014 | loop44: |
4748 | do { | 6015 | do { |
4749 | int alt41=2; | 6016 | int alt44=2; |
4750 | int LA41_0 = input.LA(1); | 6017 | int LA44_0 = input.LA(1); |
4751 | 6018 | ||
4752 | if ( (LA41_0==40) ) { | 6019 | if ( (LA44_0==40) ) { |
4753 | int LA41_1 = input.LA(2); | 6020 | int LA44_1 = input.LA(2); |
4754 | 6021 | ||
4755 | if ( (LA41_1==RULE_ID||(LA41_1>=41 && LA41_1<=42)) ) { | 6022 | if ( (LA44_1==RULE_ID||(LA44_1>=41 && LA44_1<=44)) ) { |
4756 | alt41=1; | 6023 | alt44=1; |
4757 | } | 6024 | } |
4758 | 6025 | ||
4759 | 6026 | ||
4760 | } | 6027 | } |
4761 | 6028 | ||
4762 | 6029 | ||
4763 | switch (alt41) { | 6030 | switch (alt44) { |
4764 | case 1 : | 6031 | case 1 : |
4765 | // InternalProblem.g:1761:5: kw= '::' this_Identifier_3= ruleIdentifier | 6032 | // InternalProblem.g:2179:5: kw= '::' this_Identifier_3= ruleIdentifier |
4766 | { | 6033 | { |
4767 | kw=(Token)match(input,40,FOLLOW_3); | 6034 | kw=(Token)match(input,40,FOLLOW_3); |
4768 | 6035 | ||
@@ -4772,7 +6039,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4772 | 6039 | ||
4773 | newCompositeNode(grammarAccess.getQualifiedNameAccess().getIdentifierParserRuleCall_1_1_1()); | 6040 | newCompositeNode(grammarAccess.getQualifiedNameAccess().getIdentifierParserRuleCall_1_1_1()); |
4774 | 6041 | ||
4775 | pushFollow(FOLLOW_36); | 6042 | pushFollow(FOLLOW_38); |
4776 | this_Identifier_3=ruleIdentifier(); | 6043 | this_Identifier_3=ruleIdentifier(); |
4777 | 6044 | ||
4778 | state._fsp--; | 6045 | state._fsp--; |
@@ -4788,22 +6055,22 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4788 | break; | 6055 | break; |
4789 | 6056 | ||
4790 | default : | 6057 | default : |
4791 | break loop41; | 6058 | break loop44; |
4792 | } | 6059 | } |
4793 | } while (true); | 6060 | } while (true); |
4794 | 6061 | ||
4795 | // InternalProblem.g:1777:4: (kw= '::' this_QUOTED_ID_5= RULE_QUOTED_ID )? | 6062 | // InternalProblem.g:2195:4: (kw= '::' this_QUOTED_ID_5= RULE_QUOTED_ID )? |
4796 | int alt42=2; | 6063 | int alt45=2; |
4797 | int LA42_0 = input.LA(1); | 6064 | int LA45_0 = input.LA(1); |
4798 | 6065 | ||
4799 | if ( (LA42_0==40) ) { | 6066 | if ( (LA45_0==40) ) { |
4800 | alt42=1; | 6067 | alt45=1; |
4801 | } | 6068 | } |
4802 | switch (alt42) { | 6069 | switch (alt45) { |
4803 | case 1 : | 6070 | case 1 : |
4804 | // InternalProblem.g:1778:5: kw= '::' this_QUOTED_ID_5= RULE_QUOTED_ID | 6071 | // InternalProblem.g:2196:5: kw= '::' this_QUOTED_ID_5= RULE_QUOTED_ID |
4805 | { | 6072 | { |
4806 | kw=(Token)match(input,40,FOLLOW_37); | 6073 | kw=(Token)match(input,40,FOLLOW_39); |
4807 | 6074 | ||
4808 | current.merge(kw); | 6075 | current.merge(kw); |
4809 | newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getColonColonKeyword_1_2_0()); | 6076 | newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getColonColonKeyword_1_2_0()); |
@@ -4843,6 +6110,9 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4843 | appendSkippedTokens(); | 6110 | appendSkippedTokens(); |
4844 | } | 6111 | } |
4845 | finally { | 6112 | finally { |
6113 | |||
6114 | myHiddenTokenState.restore(); | ||
6115 | |||
4846 | } | 6116 | } |
4847 | return current; | 6117 | return current; |
4848 | } | 6118 | } |
@@ -4850,7 +6120,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4850 | 6120 | ||
4851 | 6121 | ||
4852 | // $ANTLR start "entryRuleIdentifier" | 6122 | // $ANTLR start "entryRuleIdentifier" |
4853 | // InternalProblem.g:1796:1: entryRuleIdentifier returns [String current=null] : iv_ruleIdentifier= ruleIdentifier EOF ; | 6123 | // InternalProblem.g:2217:1: entryRuleIdentifier returns [String current=null] : iv_ruleIdentifier= ruleIdentifier EOF ; |
4854 | public final String entryRuleIdentifier() throws RecognitionException { | 6124 | public final String entryRuleIdentifier() throws RecognitionException { |
4855 | String current = null; | 6125 | String current = null; |
4856 | 6126 | ||
@@ -4858,8 +6128,8 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4858 | 6128 | ||
4859 | 6129 | ||
4860 | try { | 6130 | try { |
4861 | // InternalProblem.g:1796:50: (iv_ruleIdentifier= ruleIdentifier EOF ) | 6131 | // InternalProblem.g:2217:50: (iv_ruleIdentifier= ruleIdentifier EOF ) |
4862 | // InternalProblem.g:1797:2: iv_ruleIdentifier= ruleIdentifier EOF | 6132 | // InternalProblem.g:2218:2: iv_ruleIdentifier= ruleIdentifier EOF |
4863 | { | 6133 | { |
4864 | newCompositeNode(grammarAccess.getIdentifierRule()); | 6134 | newCompositeNode(grammarAccess.getIdentifierRule()); |
4865 | pushFollow(FOLLOW_1); | 6135 | pushFollow(FOLLOW_1); |
@@ -4886,7 +6156,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4886 | 6156 | ||
4887 | 6157 | ||
4888 | // $ANTLR start "ruleIdentifier" | 6158 | // $ANTLR start "ruleIdentifier" |
4889 | // InternalProblem.g:1803:1: ruleIdentifier returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ID_0= RULE_ID | kw= 'true' | kw= 'false' ) ; | 6159 | // InternalProblem.g:2224:1: ruleIdentifier returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ID_0= RULE_ID | kw= 'true' | kw= 'false' | kw= 'e' | kw= 'E' ) ; |
4890 | public final AntlrDatatypeRuleToken ruleIdentifier() throws RecognitionException { | 6160 | public final AntlrDatatypeRuleToken ruleIdentifier() throws RecognitionException { |
4891 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); | 6161 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); |
4892 | 6162 | ||
@@ -4897,37 +6167,47 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4897 | enterRule(); | 6167 | enterRule(); |
4898 | 6168 | ||
4899 | try { | 6169 | try { |
4900 | // InternalProblem.g:1809:2: ( (this_ID_0= RULE_ID | kw= 'true' | kw= 'false' ) ) | 6170 | // InternalProblem.g:2230:2: ( (this_ID_0= RULE_ID | kw= 'true' | kw= 'false' | kw= 'e' | kw= 'E' ) ) |
4901 | // InternalProblem.g:1810:2: (this_ID_0= RULE_ID | kw= 'true' | kw= 'false' ) | 6171 | // InternalProblem.g:2231:2: (this_ID_0= RULE_ID | kw= 'true' | kw= 'false' | kw= 'e' | kw= 'E' ) |
4902 | { | 6172 | { |
4903 | // InternalProblem.g:1810:2: (this_ID_0= RULE_ID | kw= 'true' | kw= 'false' ) | 6173 | // InternalProblem.g:2231:2: (this_ID_0= RULE_ID | kw= 'true' | kw= 'false' | kw= 'e' | kw= 'E' ) |
4904 | int alt44=3; | 6174 | int alt47=5; |
4905 | switch ( input.LA(1) ) { | 6175 | switch ( input.LA(1) ) { |
4906 | case RULE_ID: | 6176 | case RULE_ID: |
4907 | { | 6177 | { |
4908 | alt44=1; | 6178 | alt47=1; |
4909 | } | 6179 | } |
4910 | break; | 6180 | break; |
4911 | case 41: | 6181 | case 41: |
4912 | { | 6182 | { |
4913 | alt44=2; | 6183 | alt47=2; |
4914 | } | 6184 | } |
4915 | break; | 6185 | break; |
4916 | case 42: | 6186 | case 42: |
4917 | { | 6187 | { |
4918 | alt44=3; | 6188 | alt47=3; |
6189 | } | ||
6190 | break; | ||
6191 | case 43: | ||
6192 | { | ||
6193 | alt47=4; | ||
6194 | } | ||
6195 | break; | ||
6196 | case 44: | ||
6197 | { | ||
6198 | alt47=5; | ||
4919 | } | 6199 | } |
4920 | break; | 6200 | break; |
4921 | default: | 6201 | default: |
4922 | NoViableAltException nvae = | 6202 | NoViableAltException nvae = |
4923 | new NoViableAltException("", 44, 0, input); | 6203 | new NoViableAltException("", 47, 0, input); |
4924 | 6204 | ||
4925 | throw nvae; | 6205 | throw nvae; |
4926 | } | 6206 | } |
4927 | 6207 | ||
4928 | switch (alt44) { | 6208 | switch (alt47) { |
4929 | case 1 : | 6209 | case 1 : |
4930 | // InternalProblem.g:1811:3: this_ID_0= RULE_ID | 6210 | // InternalProblem.g:2232:3: this_ID_0= RULE_ID |
4931 | { | 6211 | { |
4932 | this_ID_0=(Token)match(input,RULE_ID,FOLLOW_2); | 6212 | this_ID_0=(Token)match(input,RULE_ID,FOLLOW_2); |
4933 | 6213 | ||
@@ -4940,7 +6220,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4940 | } | 6220 | } |
4941 | break; | 6221 | break; |
4942 | case 2 : | 6222 | case 2 : |
4943 | // InternalProblem.g:1819:3: kw= 'true' | 6223 | // InternalProblem.g:2240:3: kw= 'true' |
4944 | { | 6224 | { |
4945 | kw=(Token)match(input,41,FOLLOW_2); | 6225 | kw=(Token)match(input,41,FOLLOW_2); |
4946 | 6226 | ||
@@ -4951,7 +6231,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4951 | } | 6231 | } |
4952 | break; | 6232 | break; |
4953 | case 3 : | 6233 | case 3 : |
4954 | // InternalProblem.g:1825:3: kw= 'false' | 6234 | // InternalProblem.g:2246:3: kw= 'false' |
4955 | { | 6235 | { |
4956 | kw=(Token)match(input,42,FOLLOW_2); | 6236 | kw=(Token)match(input,42,FOLLOW_2); |
4957 | 6237 | ||
@@ -4961,6 +6241,28 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4961 | 6241 | ||
4962 | } | 6242 | } |
4963 | break; | 6243 | break; |
6244 | case 4 : | ||
6245 | // InternalProblem.g:2252:3: kw= 'e' | ||
6246 | { | ||
6247 | kw=(Token)match(input,43,FOLLOW_2); | ||
6248 | |||
6249 | current.merge(kw); | ||
6250 | newLeafNode(kw, grammarAccess.getIdentifierAccess().getEKeyword_3()); | ||
6251 | |||
6252 | |||
6253 | } | ||
6254 | break; | ||
6255 | case 5 : | ||
6256 | // InternalProblem.g:2258:3: kw= 'E' | ||
6257 | { | ||
6258 | kw=(Token)match(input,44,FOLLOW_2); | ||
6259 | |||
6260 | current.merge(kw); | ||
6261 | newLeafNode(kw, grammarAccess.getIdentifierAccess().getEKeyword_4()); | ||
6262 | |||
6263 | |||
6264 | } | ||
6265 | break; | ||
4964 | 6266 | ||
4965 | } | 6267 | } |
4966 | 6268 | ||
@@ -4983,8 +6285,434 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4983 | // $ANTLR end "ruleIdentifier" | 6285 | // $ANTLR end "ruleIdentifier" |
4984 | 6286 | ||
4985 | 6287 | ||
6288 | // $ANTLR start "entryRuleInteger" | ||
6289 | // InternalProblem.g:2267:1: entryRuleInteger returns [String current=null] : iv_ruleInteger= ruleInteger EOF ; | ||
6290 | public final String entryRuleInteger() throws RecognitionException { | ||
6291 | String current = null; | ||
6292 | |||
6293 | AntlrDatatypeRuleToken iv_ruleInteger = null; | ||
6294 | |||
6295 | |||
6296 | |||
6297 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
6298 | |||
6299 | try { | ||
6300 | // InternalProblem.g:2269:2: (iv_ruleInteger= ruleInteger EOF ) | ||
6301 | // InternalProblem.g:2270:2: iv_ruleInteger= ruleInteger EOF | ||
6302 | { | ||
6303 | newCompositeNode(grammarAccess.getIntegerRule()); | ||
6304 | pushFollow(FOLLOW_1); | ||
6305 | iv_ruleInteger=ruleInteger(); | ||
6306 | |||
6307 | state._fsp--; | ||
6308 | |||
6309 | current =iv_ruleInteger.getText(); | ||
6310 | match(input,EOF,FOLLOW_2); | ||
6311 | |||
6312 | } | ||
6313 | |||
6314 | } | ||
6315 | |||
6316 | catch (RecognitionException re) { | ||
6317 | recover(input,re); | ||
6318 | appendSkippedTokens(); | ||
6319 | } | ||
6320 | finally { | ||
6321 | |||
6322 | myHiddenTokenState.restore(); | ||
6323 | |||
6324 | } | ||
6325 | return current; | ||
6326 | } | ||
6327 | // $ANTLR end "entryRuleInteger" | ||
6328 | |||
6329 | |||
6330 | // $ANTLR start "ruleInteger" | ||
6331 | // InternalProblem.g:2279:1: ruleInteger returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= '-' )? this_INT_1= RULE_INT ) ; | ||
6332 | public final AntlrDatatypeRuleToken ruleInteger() throws RecognitionException { | ||
6333 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); | ||
6334 | |||
6335 | Token kw=null; | ||
6336 | Token this_INT_1=null; | ||
6337 | |||
6338 | |||
6339 | enterRule(); | ||
6340 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
6341 | |||
6342 | try { | ||
6343 | // InternalProblem.g:2286:2: ( ( (kw= '-' )? this_INT_1= RULE_INT ) ) | ||
6344 | // InternalProblem.g:2287:2: ( (kw= '-' )? this_INT_1= RULE_INT ) | ||
6345 | { | ||
6346 | // InternalProblem.g:2287:2: ( (kw= '-' )? this_INT_1= RULE_INT ) | ||
6347 | // InternalProblem.g:2288:3: (kw= '-' )? this_INT_1= RULE_INT | ||
6348 | { | ||
6349 | // InternalProblem.g:2288:3: (kw= '-' )? | ||
6350 | int alt48=2; | ||
6351 | int LA48_0 = input.LA(1); | ||
6352 | |||
6353 | if ( (LA48_0==45) ) { | ||
6354 | alt48=1; | ||
6355 | } | ||
6356 | switch (alt48) { | ||
6357 | case 1 : | ||
6358 | // InternalProblem.g:2289:4: kw= '-' | ||
6359 | { | ||
6360 | kw=(Token)match(input,45,FOLLOW_17); | ||
6361 | |||
6362 | current.merge(kw); | ||
6363 | newLeafNode(kw, grammarAccess.getIntegerAccess().getHyphenMinusKeyword_0()); | ||
6364 | |||
6365 | |||
6366 | } | ||
6367 | break; | ||
6368 | |||
6369 | } | ||
6370 | |||
6371 | this_INT_1=(Token)match(input,RULE_INT,FOLLOW_2); | ||
6372 | |||
6373 | current.merge(this_INT_1); | ||
6374 | |||
6375 | |||
6376 | newLeafNode(this_INT_1, grammarAccess.getIntegerAccess().getINTTerminalRuleCall_1()); | ||
6377 | |||
6378 | |||
6379 | } | ||
6380 | |||
6381 | |||
6382 | } | ||
6383 | |||
6384 | |||
6385 | leaveRule(); | ||
6386 | |||
6387 | } | ||
6388 | |||
6389 | catch (RecognitionException re) { | ||
6390 | recover(input,re); | ||
6391 | appendSkippedTokens(); | ||
6392 | } | ||
6393 | finally { | ||
6394 | |||
6395 | myHiddenTokenState.restore(); | ||
6396 | |||
6397 | } | ||
6398 | return current; | ||
6399 | } | ||
6400 | // $ANTLR end "ruleInteger" | ||
6401 | |||
6402 | |||
6403 | // $ANTLR start "entryRuleReal" | ||
6404 | // InternalProblem.g:2309:1: entryRuleReal returns [String current=null] : iv_ruleReal= ruleReal EOF ; | ||
6405 | public final String entryRuleReal() throws RecognitionException { | ||
6406 | String current = null; | ||
6407 | |||
6408 | AntlrDatatypeRuleToken iv_ruleReal = null; | ||
6409 | |||
6410 | |||
6411 | |||
6412 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
6413 | |||
6414 | try { | ||
6415 | // InternalProblem.g:2311:2: (iv_ruleReal= ruleReal EOF ) | ||
6416 | // InternalProblem.g:2312:2: iv_ruleReal= ruleReal EOF | ||
6417 | { | ||
6418 | newCompositeNode(grammarAccess.getRealRule()); | ||
6419 | pushFollow(FOLLOW_1); | ||
6420 | iv_ruleReal=ruleReal(); | ||
6421 | |||
6422 | state._fsp--; | ||
6423 | |||
6424 | current =iv_ruleReal.getText(); | ||
6425 | match(input,EOF,FOLLOW_2); | ||
6426 | |||
6427 | } | ||
6428 | |||
6429 | } | ||
6430 | |||
6431 | catch (RecognitionException re) { | ||
6432 | recover(input,re); | ||
6433 | appendSkippedTokens(); | ||
6434 | } | ||
6435 | finally { | ||
6436 | |||
6437 | myHiddenTokenState.restore(); | ||
6438 | |||
6439 | } | ||
6440 | return current; | ||
6441 | } | ||
6442 | // $ANTLR end "entryRuleReal" | ||
6443 | |||
6444 | |||
6445 | // $ANTLR start "ruleReal" | ||
6446 | // InternalProblem.g:2321:1: ruleReal returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= '-' )? this_INT_1= RULE_INT ( (kw= '.' this_INT_3= RULE_INT ) | ( (kw= '.' this_INT_5= RULE_INT )? (kw= 'e' | kw= 'E' ) (kw= '-' | kw= '+' )? this_INT_10= RULE_INT ) ) ) ; | ||
6447 | public final AntlrDatatypeRuleToken ruleReal() throws RecognitionException { | ||
6448 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); | ||
6449 | |||
6450 | Token kw=null; | ||
6451 | Token this_INT_1=null; | ||
6452 | Token this_INT_3=null; | ||
6453 | Token this_INT_5=null; | ||
6454 | Token this_INT_10=null; | ||
6455 | |||
6456 | |||
6457 | enterRule(); | ||
6458 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
6459 | |||
6460 | try { | ||
6461 | // InternalProblem.g:2328:2: ( ( (kw= '-' )? this_INT_1= RULE_INT ( (kw= '.' this_INT_3= RULE_INT ) | ( (kw= '.' this_INT_5= RULE_INT )? (kw= 'e' | kw= 'E' ) (kw= '-' | kw= '+' )? this_INT_10= RULE_INT ) ) ) ) | ||
6462 | // InternalProblem.g:2329:2: ( (kw= '-' )? this_INT_1= RULE_INT ( (kw= '.' this_INT_3= RULE_INT ) | ( (kw= '.' this_INT_5= RULE_INT )? (kw= 'e' | kw= 'E' ) (kw= '-' | kw= '+' )? this_INT_10= RULE_INT ) ) ) | ||
6463 | { | ||
6464 | // InternalProblem.g:2329:2: ( (kw= '-' )? this_INT_1= RULE_INT ( (kw= '.' this_INT_3= RULE_INT ) | ( (kw= '.' this_INT_5= RULE_INT )? (kw= 'e' | kw= 'E' ) (kw= '-' | kw= '+' )? this_INT_10= RULE_INT ) ) ) | ||
6465 | // InternalProblem.g:2330:3: (kw= '-' )? this_INT_1= RULE_INT ( (kw= '.' this_INT_3= RULE_INT ) | ( (kw= '.' this_INT_5= RULE_INT )? (kw= 'e' | kw= 'E' ) (kw= '-' | kw= '+' )? this_INT_10= RULE_INT ) ) | ||
6466 | { | ||
6467 | // InternalProblem.g:2330:3: (kw= '-' )? | ||
6468 | int alt49=2; | ||
6469 | int LA49_0 = input.LA(1); | ||
6470 | |||
6471 | if ( (LA49_0==45) ) { | ||
6472 | alt49=1; | ||
6473 | } | ||
6474 | switch (alt49) { | ||
6475 | case 1 : | ||
6476 | // InternalProblem.g:2331:4: kw= '-' | ||
6477 | { | ||
6478 | kw=(Token)match(input,45,FOLLOW_17); | ||
6479 | |||
6480 | current.merge(kw); | ||
6481 | newLeafNode(kw, grammarAccess.getRealAccess().getHyphenMinusKeyword_0()); | ||
6482 | |||
6483 | |||
6484 | } | ||
6485 | break; | ||
6486 | |||
6487 | } | ||
6488 | |||
6489 | this_INT_1=(Token)match(input,RULE_INT,FOLLOW_40); | ||
6490 | |||
6491 | current.merge(this_INT_1); | ||
6492 | |||
6493 | |||
6494 | newLeafNode(this_INT_1, grammarAccess.getRealAccess().getINTTerminalRuleCall_1()); | ||
6495 | |||
6496 | // InternalProblem.g:2344:3: ( (kw= '.' this_INT_3= RULE_INT ) | ( (kw= '.' this_INT_5= RULE_INT )? (kw= 'e' | kw= 'E' ) (kw= '-' | kw= '+' )? this_INT_10= RULE_INT ) ) | ||
6497 | int alt53=2; | ||
6498 | int LA53_0 = input.LA(1); | ||
6499 | |||
6500 | if ( (LA53_0==13) ) { | ||
6501 | int LA53_1 = input.LA(2); | ||
6502 | |||
6503 | if ( (LA53_1==RULE_INT) ) { | ||
6504 | int LA53_3 = input.LA(3); | ||
6505 | |||
6506 | if ( ((LA53_3>=43 && LA53_3<=44)) ) { | ||
6507 | alt53=2; | ||
6508 | } | ||
6509 | else if ( (LA53_3==EOF||LA53_3==13||LA53_3==17||LA53_3==30) ) { | ||
6510 | alt53=1; | ||
6511 | } | ||
6512 | else { | ||
6513 | NoViableAltException nvae = | ||
6514 | new NoViableAltException("", 53, 3, input); | ||
6515 | |||
6516 | throw nvae; | ||
6517 | } | ||
6518 | } | ||
6519 | else { | ||
6520 | NoViableAltException nvae = | ||
6521 | new NoViableAltException("", 53, 1, input); | ||
6522 | |||
6523 | throw nvae; | ||
6524 | } | ||
6525 | } | ||
6526 | else if ( ((LA53_0>=43 && LA53_0<=44)) ) { | ||
6527 | alt53=2; | ||
6528 | } | ||
6529 | else { | ||
6530 | NoViableAltException nvae = | ||
6531 | new NoViableAltException("", 53, 0, input); | ||
6532 | |||
6533 | throw nvae; | ||
6534 | } | ||
6535 | switch (alt53) { | ||
6536 | case 1 : | ||
6537 | // InternalProblem.g:2345:4: (kw= '.' this_INT_3= RULE_INT ) | ||
6538 | { | ||
6539 | // InternalProblem.g:2345:4: (kw= '.' this_INT_3= RULE_INT ) | ||
6540 | // InternalProblem.g:2346:5: kw= '.' this_INT_3= RULE_INT | ||
6541 | { | ||
6542 | kw=(Token)match(input,13,FOLLOW_17); | ||
6543 | |||
6544 | current.merge(kw); | ||
6545 | newLeafNode(kw, grammarAccess.getRealAccess().getFullStopKeyword_2_0_0()); | ||
6546 | |||
6547 | this_INT_3=(Token)match(input,RULE_INT,FOLLOW_2); | ||
6548 | |||
6549 | current.merge(this_INT_3); | ||
6550 | |||
6551 | |||
6552 | newLeafNode(this_INT_3, grammarAccess.getRealAccess().getINTTerminalRuleCall_2_0_1()); | ||
6553 | |||
6554 | |||
6555 | } | ||
6556 | |||
6557 | |||
6558 | } | ||
6559 | break; | ||
6560 | case 2 : | ||
6561 | // InternalProblem.g:2360:4: ( (kw= '.' this_INT_5= RULE_INT )? (kw= 'e' | kw= 'E' ) (kw= '-' | kw= '+' )? this_INT_10= RULE_INT ) | ||
6562 | { | ||
6563 | // InternalProblem.g:2360:4: ( (kw= '.' this_INT_5= RULE_INT )? (kw= 'e' | kw= 'E' ) (kw= '-' | kw= '+' )? this_INT_10= RULE_INT ) | ||
6564 | // InternalProblem.g:2361:5: (kw= '.' this_INT_5= RULE_INT )? (kw= 'e' | kw= 'E' ) (kw= '-' | kw= '+' )? this_INT_10= RULE_INT | ||
6565 | { | ||
6566 | // InternalProblem.g:2361:5: (kw= '.' this_INT_5= RULE_INT )? | ||
6567 | int alt50=2; | ||
6568 | int LA50_0 = input.LA(1); | ||
6569 | |||
6570 | if ( (LA50_0==13) ) { | ||
6571 | alt50=1; | ||
6572 | } | ||
6573 | switch (alt50) { | ||
6574 | case 1 : | ||
6575 | // InternalProblem.g:2362:6: kw= '.' this_INT_5= RULE_INT | ||
6576 | { | ||
6577 | kw=(Token)match(input,13,FOLLOW_17); | ||
6578 | |||
6579 | current.merge(kw); | ||
6580 | newLeafNode(kw, grammarAccess.getRealAccess().getFullStopKeyword_2_1_0_0()); | ||
6581 | |||
6582 | this_INT_5=(Token)match(input,RULE_INT,FOLLOW_41); | ||
6583 | |||
6584 | current.merge(this_INT_5); | ||
6585 | |||
6586 | |||
6587 | newLeafNode(this_INT_5, grammarAccess.getRealAccess().getINTTerminalRuleCall_2_1_0_1()); | ||
6588 | |||
6589 | |||
6590 | } | ||
6591 | break; | ||
6592 | |||
6593 | } | ||
6594 | |||
6595 | // InternalProblem.g:2375:5: (kw= 'e' | kw= 'E' ) | ||
6596 | int alt51=2; | ||
6597 | int LA51_0 = input.LA(1); | ||
6598 | |||
6599 | if ( (LA51_0==43) ) { | ||
6600 | alt51=1; | ||
6601 | } | ||
6602 | else if ( (LA51_0==44) ) { | ||
6603 | alt51=2; | ||
6604 | } | ||
6605 | else { | ||
6606 | NoViableAltException nvae = | ||
6607 | new NoViableAltException("", 51, 0, input); | ||
6608 | |||
6609 | throw nvae; | ||
6610 | } | ||
6611 | switch (alt51) { | ||
6612 | case 1 : | ||
6613 | // InternalProblem.g:2376:6: kw= 'e' | ||
6614 | { | ||
6615 | kw=(Token)match(input,43,FOLLOW_42); | ||
6616 | |||
6617 | current.merge(kw); | ||
6618 | newLeafNode(kw, grammarAccess.getRealAccess().getEKeyword_2_1_1_0()); | ||
6619 | |||
6620 | |||
6621 | } | ||
6622 | break; | ||
6623 | case 2 : | ||
6624 | // InternalProblem.g:2382:6: kw= 'E' | ||
6625 | { | ||
6626 | kw=(Token)match(input,44,FOLLOW_42); | ||
6627 | |||
6628 | current.merge(kw); | ||
6629 | newLeafNode(kw, grammarAccess.getRealAccess().getEKeyword_2_1_1_1()); | ||
6630 | |||
6631 | |||
6632 | } | ||
6633 | break; | ||
6634 | |||
6635 | } | ||
6636 | |||
6637 | // InternalProblem.g:2388:5: (kw= '-' | kw= '+' )? | ||
6638 | int alt52=3; | ||
6639 | int LA52_0 = input.LA(1); | ||
6640 | |||
6641 | if ( (LA52_0==45) ) { | ||
6642 | alt52=1; | ||
6643 | } | ||
6644 | else if ( (LA52_0==33) ) { | ||
6645 | alt52=2; | ||
6646 | } | ||
6647 | switch (alt52) { | ||
6648 | case 1 : | ||
6649 | // InternalProblem.g:2389:6: kw= '-' | ||
6650 | { | ||
6651 | kw=(Token)match(input,45,FOLLOW_17); | ||
6652 | |||
6653 | current.merge(kw); | ||
6654 | newLeafNode(kw, grammarAccess.getRealAccess().getHyphenMinusKeyword_2_1_2_0()); | ||
6655 | |||
6656 | |||
6657 | } | ||
6658 | break; | ||
6659 | case 2 : | ||
6660 | // InternalProblem.g:2395:6: kw= '+' | ||
6661 | { | ||
6662 | kw=(Token)match(input,33,FOLLOW_17); | ||
6663 | |||
6664 | current.merge(kw); | ||
6665 | newLeafNode(kw, grammarAccess.getRealAccess().getPlusSignKeyword_2_1_2_1()); | ||
6666 | |||
6667 | |||
6668 | } | ||
6669 | break; | ||
6670 | |||
6671 | } | ||
6672 | |||
6673 | this_INT_10=(Token)match(input,RULE_INT,FOLLOW_2); | ||
6674 | |||
6675 | current.merge(this_INT_10); | ||
6676 | |||
6677 | |||
6678 | newLeafNode(this_INT_10, grammarAccess.getRealAccess().getINTTerminalRuleCall_2_1_3()); | ||
6679 | |||
6680 | |||
6681 | } | ||
6682 | |||
6683 | |||
6684 | } | ||
6685 | break; | ||
6686 | |||
6687 | } | ||
6688 | |||
6689 | |||
6690 | } | ||
6691 | |||
6692 | |||
6693 | } | ||
6694 | |||
6695 | |||
6696 | leaveRule(); | ||
6697 | |||
6698 | } | ||
6699 | |||
6700 | catch (RecognitionException re) { | ||
6701 | recover(input,re); | ||
6702 | appendSkippedTokens(); | ||
6703 | } | ||
6704 | finally { | ||
6705 | |||
6706 | myHiddenTokenState.restore(); | ||
6707 | |||
6708 | } | ||
6709 | return current; | ||
6710 | } | ||
6711 | // $ANTLR end "ruleReal" | ||
6712 | |||
6713 | |||
4986 | // $ANTLR start "ruleLogicValue" | 6714 | // $ANTLR start "ruleLogicValue" |
4987 | // InternalProblem.g:1834:1: ruleLogicValue returns [Enumerator current=null] : ( (enumLiteral_0= 'true' ) | (enumLiteral_1= 'false' ) | (enumLiteral_2= 'unknown' ) ) ; | 6715 | // InternalProblem.g:2417:1: ruleLogicValue returns [Enumerator current=null] : ( (enumLiteral_0= 'true' ) | (enumLiteral_1= 'false' ) | (enumLiteral_2= 'unknown' ) ) ; |
4988 | public final Enumerator ruleLogicValue() throws RecognitionException { | 6716 | public final Enumerator ruleLogicValue() throws RecognitionException { |
4989 | Enumerator current = null; | 6717 | Enumerator current = null; |
4990 | 6718 | ||
@@ -4996,40 +6724,40 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
4996 | enterRule(); | 6724 | enterRule(); |
4997 | 6725 | ||
4998 | try { | 6726 | try { |
4999 | // InternalProblem.g:1840:2: ( ( (enumLiteral_0= 'true' ) | (enumLiteral_1= 'false' ) | (enumLiteral_2= 'unknown' ) ) ) | 6727 | // InternalProblem.g:2423:2: ( ( (enumLiteral_0= 'true' ) | (enumLiteral_1= 'false' ) | (enumLiteral_2= 'unknown' ) ) ) |
5000 | // InternalProblem.g:1841:2: ( (enumLiteral_0= 'true' ) | (enumLiteral_1= 'false' ) | (enumLiteral_2= 'unknown' ) ) | 6728 | // InternalProblem.g:2424:2: ( (enumLiteral_0= 'true' ) | (enumLiteral_1= 'false' ) | (enumLiteral_2= 'unknown' ) ) |
5001 | { | 6729 | { |
5002 | // InternalProblem.g:1841:2: ( (enumLiteral_0= 'true' ) | (enumLiteral_1= 'false' ) | (enumLiteral_2= 'unknown' ) ) | 6730 | // InternalProblem.g:2424:2: ( (enumLiteral_0= 'true' ) | (enumLiteral_1= 'false' ) | (enumLiteral_2= 'unknown' ) ) |
5003 | int alt45=3; | 6731 | int alt54=3; |
5004 | switch ( input.LA(1) ) { | 6732 | switch ( input.LA(1) ) { |
5005 | case 41: | 6733 | case 41: |
5006 | { | 6734 | { |
5007 | alt45=1; | 6735 | alt54=1; |
5008 | } | 6736 | } |
5009 | break; | 6737 | break; |
5010 | case 42: | 6738 | case 42: |
5011 | { | 6739 | { |
5012 | alt45=2; | 6740 | alt54=2; |
5013 | } | 6741 | } |
5014 | break; | 6742 | break; |
5015 | case 43: | 6743 | case 46: |
5016 | { | 6744 | { |
5017 | alt45=3; | 6745 | alt54=3; |
5018 | } | 6746 | } |
5019 | break; | 6747 | break; |
5020 | default: | 6748 | default: |
5021 | NoViableAltException nvae = | 6749 | NoViableAltException nvae = |
5022 | new NoViableAltException("", 45, 0, input); | 6750 | new NoViableAltException("", 54, 0, input); |
5023 | 6751 | ||
5024 | throw nvae; | 6752 | throw nvae; |
5025 | } | 6753 | } |
5026 | 6754 | ||
5027 | switch (alt45) { | 6755 | switch (alt54) { |
5028 | case 1 : | 6756 | case 1 : |
5029 | // InternalProblem.g:1842:3: (enumLiteral_0= 'true' ) | 6757 | // InternalProblem.g:2425:3: (enumLiteral_0= 'true' ) |
5030 | { | 6758 | { |
5031 | // InternalProblem.g:1842:3: (enumLiteral_0= 'true' ) | 6759 | // InternalProblem.g:2425:3: (enumLiteral_0= 'true' ) |
5032 | // InternalProblem.g:1843:4: enumLiteral_0= 'true' | 6760 | // InternalProblem.g:2426:4: enumLiteral_0= 'true' |
5033 | { | 6761 | { |
5034 | enumLiteral_0=(Token)match(input,41,FOLLOW_2); | 6762 | enumLiteral_0=(Token)match(input,41,FOLLOW_2); |
5035 | 6763 | ||
@@ -5043,10 +6771,10 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
5043 | } | 6771 | } |
5044 | break; | 6772 | break; |
5045 | case 2 : | 6773 | case 2 : |
5046 | // InternalProblem.g:1850:3: (enumLiteral_1= 'false' ) | 6774 | // InternalProblem.g:2433:3: (enumLiteral_1= 'false' ) |
5047 | { | 6775 | { |
5048 | // InternalProblem.g:1850:3: (enumLiteral_1= 'false' ) | 6776 | // InternalProblem.g:2433:3: (enumLiteral_1= 'false' ) |
5049 | // InternalProblem.g:1851:4: enumLiteral_1= 'false' | 6777 | // InternalProblem.g:2434:4: enumLiteral_1= 'false' |
5050 | { | 6778 | { |
5051 | enumLiteral_1=(Token)match(input,42,FOLLOW_2); | 6779 | enumLiteral_1=(Token)match(input,42,FOLLOW_2); |
5052 | 6780 | ||
@@ -5060,12 +6788,12 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
5060 | } | 6788 | } |
5061 | break; | 6789 | break; |
5062 | case 3 : | 6790 | case 3 : |
5063 | // InternalProblem.g:1858:3: (enumLiteral_2= 'unknown' ) | 6791 | // InternalProblem.g:2441:3: (enumLiteral_2= 'unknown' ) |
5064 | { | 6792 | { |
5065 | // InternalProblem.g:1858:3: (enumLiteral_2= 'unknown' ) | 6793 | // InternalProblem.g:2441:3: (enumLiteral_2= 'unknown' ) |
5066 | // InternalProblem.g:1859:4: enumLiteral_2= 'unknown' | 6794 | // InternalProblem.g:2442:4: enumLiteral_2= 'unknown' |
5067 | { | 6795 | { |
5068 | enumLiteral_2=(Token)match(input,43,FOLLOW_2); | 6796 | enumLiteral_2=(Token)match(input,46,FOLLOW_2); |
5069 | 6797 | ||
5070 | current = grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | 6798 | current = grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); |
5071 | newLeafNode(enumLiteral_2, grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); | 6799 | newLeafNode(enumLiteral_2, grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); |
@@ -5099,7 +6827,7 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
5099 | 6827 | ||
5100 | 6828 | ||
5101 | // $ANTLR start "ruleShortLogicValue" | 6829 | // $ANTLR start "ruleShortLogicValue" |
5102 | // InternalProblem.g:1869:1: ruleShortLogicValue returns [Enumerator current=null] : ( (enumLiteral_0= '!' ) | (enumLiteral_1= '?' ) ) ; | 6830 | // InternalProblem.g:2452:1: ruleShortLogicValue returns [Enumerator current=null] : ( (enumLiteral_0= '!' ) | (enumLiteral_1= '?' ) ) ; |
5103 | public final Enumerator ruleShortLogicValue() throws RecognitionException { | 6831 | public final Enumerator ruleShortLogicValue() throws RecognitionException { |
5104 | Enumerator current = null; | 6832 | Enumerator current = null; |
5105 | 6833 | ||
@@ -5110,31 +6838,31 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
5110 | enterRule(); | 6838 | enterRule(); |
5111 | 6839 | ||
5112 | try { | 6840 | try { |
5113 | // InternalProblem.g:1875:2: ( ( (enumLiteral_0= '!' ) | (enumLiteral_1= '?' ) ) ) | 6841 | // InternalProblem.g:2458:2: ( ( (enumLiteral_0= '!' ) | (enumLiteral_1= '?' ) ) ) |
5114 | // InternalProblem.g:1876:2: ( (enumLiteral_0= '!' ) | (enumLiteral_1= '?' ) ) | 6842 | // InternalProblem.g:2459:2: ( (enumLiteral_0= '!' ) | (enumLiteral_1= '?' ) ) |
5115 | { | 6843 | { |
5116 | // InternalProblem.g:1876:2: ( (enumLiteral_0= '!' ) | (enumLiteral_1= '?' ) ) | 6844 | // InternalProblem.g:2459:2: ( (enumLiteral_0= '!' ) | (enumLiteral_1= '?' ) ) |
5117 | int alt46=2; | 6845 | int alt55=2; |
5118 | int LA46_0 = input.LA(1); | 6846 | int LA55_0 = input.LA(1); |
5119 | 6847 | ||
5120 | if ( (LA46_0==32) ) { | 6848 | if ( (LA55_0==32) ) { |
5121 | alt46=1; | 6849 | alt55=1; |
5122 | } | 6850 | } |
5123 | else if ( (LA46_0==44) ) { | 6851 | else if ( (LA55_0==47) ) { |
5124 | alt46=2; | 6852 | alt55=2; |
5125 | } | 6853 | } |
5126 | else { | 6854 | else { |
5127 | NoViableAltException nvae = | 6855 | NoViableAltException nvae = |
5128 | new NoViableAltException("", 46, 0, input); | 6856 | new NoViableAltException("", 55, 0, input); |
5129 | 6857 | ||
5130 | throw nvae; | 6858 | throw nvae; |
5131 | } | 6859 | } |
5132 | switch (alt46) { | 6860 | switch (alt55) { |
5133 | case 1 : | 6861 | case 1 : |
5134 | // InternalProblem.g:1877:3: (enumLiteral_0= '!' ) | 6862 | // InternalProblem.g:2460:3: (enumLiteral_0= '!' ) |
5135 | { | 6863 | { |
5136 | // InternalProblem.g:1877:3: (enumLiteral_0= '!' ) | 6864 | // InternalProblem.g:2460:3: (enumLiteral_0= '!' ) |
5137 | // InternalProblem.g:1878:4: enumLiteral_0= '!' | 6865 | // InternalProblem.g:2461:4: enumLiteral_0= '!' |
5138 | { | 6866 | { |
5139 | enumLiteral_0=(Token)match(input,32,FOLLOW_2); | 6867 | enumLiteral_0=(Token)match(input,32,FOLLOW_2); |
5140 | 6868 | ||
@@ -5148,12 +6876,12 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
5148 | } | 6876 | } |
5149 | break; | 6877 | break; |
5150 | case 2 : | 6878 | case 2 : |
5151 | // InternalProblem.g:1885:3: (enumLiteral_1= '?' ) | 6879 | // InternalProblem.g:2468:3: (enumLiteral_1= '?' ) |
5152 | { | 6880 | { |
5153 | // InternalProblem.g:1885:3: (enumLiteral_1= '?' ) | 6881 | // InternalProblem.g:2468:3: (enumLiteral_1= '?' ) |
5154 | // InternalProblem.g:1886:4: enumLiteral_1= '?' | 6882 | // InternalProblem.g:2469:4: enumLiteral_1= '?' |
5155 | { | 6883 | { |
5156 | enumLiteral_1=(Token)match(input,44,FOLLOW_2); | 6884 | enumLiteral_1=(Token)match(input,47,FOLLOW_2); |
5157 | 6885 | ||
5158 | current = grammarAccess.getShortLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | 6886 | current = grammarAccess.getShortLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); |
5159 | newLeafNode(enumLiteral_1, grammarAccess.getShortLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_1()); | 6887 | newLeafNode(enumLiteral_1, grammarAccess.getShortLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_1()); |
@@ -5188,46 +6916,34 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
5188 | // Delegated rules | 6916 | // Delegated rules |
5189 | 6917 | ||
5190 | 6918 | ||
5191 | protected DFA34 dfa34 = new DFA34(this); | 6919 | protected DFA3 dfa3 = new DFA3(this); |
5192 | static final String dfa_1s = "\41\uffff"; | 6920 | protected DFA35 dfa35 = new DFA35(this); |
5193 | static final String dfa_2s = "\1\4\4\35\1\uffff\2\4\4\21\1\15\4\35\2\4\1\uffff\10\21\1\4\4\21"; | 6921 | static final String dfa_1s = "\24\uffff"; |
5194 | static final String dfa_3s = "\1\54\1\35\3\50\1\uffff\2\52\1\36\3\50\1\42\3\50\1\35\2\52\1\uffff\1\36\6\50\1\36\1\52\3\50\1\36"; | 6922 | static final String dfa_2s = "\1\5\3\uffff\6\35\3\uffff\1\5\6\35"; |
5195 | static final String dfa_4s = "\5\uffff\1\2\15\uffff\1\1\15\uffff"; | 6923 | static final String dfa_3s = "\1\57\3\uffff\1\42\5\50\3\uffff\1\54\5\50\1\42"; |
5196 | static final String dfa_5s = "\41\uffff}>"; | 6924 | static final String dfa_4s = "\1\uffff\1\1\1\2\1\3\6\uffff\1\4\1\6\1\5\7\uffff"; |
6925 | static final String dfa_5s = "\24\uffff}>"; | ||
5197 | static final String[] dfa_6s = { | 6926 | static final String[] dfa_6s = { |
5198 | "\1\2\1\uffff\1\1\31\uffff\1\5\10\uffff\1\3\1\4\1\uffff\1\5", | 6927 | "\1\5\1\uffff\1\4\6\uffff\2\1\5\uffff\1\2\5\uffff\2\3\3\uffff\1\12\2\uffff\1\13\5\uffff\1\6\1\7\1\10\1\11\2\uffff\1\12", |
5199 | "\1\6", | ||
5200 | "\1\6\12\uffff\1\7", | ||
5201 | "\1\6\12\uffff\1\7", | ||
5202 | "\1\6\12\uffff\1\7", | ||
5203 | "", | 6928 | "", |
5204 | "\1\11\1\uffff\1\10\27\uffff\1\14\12\uffff\1\12\1\13", | ||
5205 | "\1\15\1\uffff\1\20\42\uffff\1\16\1\17", | ||
5206 | "\1\21\14\uffff\1\14", | ||
5207 | "\1\21\14\uffff\1\14\11\uffff\1\22", | ||
5208 | "\1\21\14\uffff\1\14\11\uffff\1\22", | ||
5209 | "\1\21\14\uffff\1\14\11\uffff\1\22", | ||
5210 | "\1\5\24\uffff\1\23", | ||
5211 | "\1\6\12\uffff\1\7", | ||
5212 | "\1\6\12\uffff\1\7", | ||
5213 | "\1\6\12\uffff\1\7", | ||
5214 | "\1\6", | ||
5215 | "\1\25\1\uffff\1\24\42\uffff\1\26\1\27", | ||
5216 | "\1\30\1\uffff\1\33\42\uffff\1\31\1\32", | ||
5217 | "", | 6929 | "", |
5218 | "\1\21\14\uffff\1\14", | 6930 | "", |
5219 | "\1\21\14\uffff\1\14\11\uffff\1\34", | 6931 | "\1\12\4\uffff\1\14", |
5220 | "\1\21\14\uffff\1\14\11\uffff\1\34", | 6932 | "\1\12\4\uffff\1\14\5\uffff\1\15", |
5221 | "\1\21\14\uffff\1\14\11\uffff\1\34", | 6933 | "\1\12\4\uffff\1\14\5\uffff\1\15", |
5222 | "\1\21\14\uffff\1\14\11\uffff\1\22", | 6934 | "\1\12\4\uffff\1\14\5\uffff\1\15", |
5223 | "\1\21\14\uffff\1\14\11\uffff\1\22", | 6935 | "\1\12\4\uffff\1\14\5\uffff\1\15", |
5224 | "\1\21\14\uffff\1\14\11\uffff\1\22", | 6936 | "\1\12\4\uffff\1\14\5\uffff\1\15", |
5225 | "\1\21\14\uffff\1\14", | 6937 | "", |
5226 | "\1\35\1\uffff\1\40\42\uffff\1\36\1\37", | 6938 | "", |
5227 | "\1\21\14\uffff\1\14\11\uffff\1\34", | 6939 | "", |
5228 | "\1\21\14\uffff\1\14\11\uffff\1\34", | 6940 | "\1\16\1\uffff\1\23\41\uffff\1\17\1\20\1\21\1\22", |
5229 | "\1\21\14\uffff\1\14\11\uffff\1\34", | 6941 | "\1\12\4\uffff\1\14\5\uffff\1\15", |
5230 | "\1\21\14\uffff\1\14" | 6942 | "\1\12\4\uffff\1\14\5\uffff\1\15", |
6943 | "\1\12\4\uffff\1\14\5\uffff\1\15", | ||
6944 | "\1\12\4\uffff\1\14\5\uffff\1\15", | ||
6945 | "\1\12\4\uffff\1\14\5\uffff\1\15", | ||
6946 | "\1\12\4\uffff\1\14" | ||
5231 | }; | 6947 | }; |
5232 | 6948 | ||
5233 | static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); | 6949 | static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); |
@@ -5237,11 +6953,11 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
5237 | static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); | 6953 | static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); |
5238 | static final short[][] dfa_6 = unpackEncodedStringArray(dfa_6s); | 6954 | static final short[][] dfa_6 = unpackEncodedStringArray(dfa_6s); |
5239 | 6955 | ||
5240 | class DFA34 extends DFA { | 6956 | class DFA3 extends DFA { |
5241 | 6957 | ||
5242 | public DFA34(BaseRecognizer recognizer) { | 6958 | public DFA3(BaseRecognizer recognizer) { |
5243 | this.recognizer = recognizer; | 6959 | this.recognizer = recognizer; |
5244 | this.decisionNumber = 34; | 6960 | this.decisionNumber = 3; |
5245 | this.eot = dfa_1; | 6961 | this.eot = dfa_1; |
5246 | this.eof = dfa_1; | 6962 | this.eof = dfa_1; |
5247 | this.min = dfa_2; | 6963 | this.min = dfa_2; |
@@ -5251,47 +6967,149 @@ public class InternalProblemParser extends AbstractInternalAntlrParser { | |||
5251 | this.transition = dfa_6; | 6967 | this.transition = dfa_6; |
5252 | } | 6968 | } |
5253 | public String getDescription() { | 6969 | public String getDescription() { |
5254 | return "1138:3: ( ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( ( ruleQualifiedName ) ) (otherlv_3= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) | ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( ( ruleQualifiedName ) ) (otherlv_12= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_14= ')' ) )"; | 6970 | return "146:2: (this_ClassDeclaration_0= ruleClassDeclaration | this_EnumDeclaration_1= ruleEnumDeclaration | this_PredicateDefinition_2= rulePredicateDefinition | this_Assertion_3= ruleAssertion | this_NodeValueAssertion_4= ruleNodeValueAssertion | this_ScopeDeclaration_5= ruleScopeDeclaration )"; |
6971 | } | ||
6972 | } | ||
6973 | static final String dfa_7s = "\101\uffff"; | ||
6974 | static final String dfa_8s = "\1\5\6\35\1\uffff\1\4\1\5\6\21\1\6\1\15\1\21\1\15\6\35\1\4\1\5\3\6\1\uffff\6\21\1\6\1\15\10\21\2\6\1\21\1\5\3\6\7\21\2\6\1\21"; | ||
6975 | static final String dfa_9s = "\1\57\1\35\5\50\1\uffff\1\55\1\54\1\36\5\50\1\6\1\54\1\36\1\42\5\50\1\35\1\55\1\54\1\6\2\55\1\uffff\1\36\5\50\1\6\1\54\1\36\5\50\1\36\1\54\2\6\1\36\1\54\1\6\2\55\5\50\1\36\1\54\2\6\1\36"; | ||
6976 | static final String dfa_10s = "\7\uffff\1\2\27\uffff\1\1\41\uffff"; | ||
6977 | static final String dfa_11s = "\101\uffff}>"; | ||
6978 | static final String[] dfa_12s = { | ||
6979 | "\1\2\1\uffff\1\1\30\uffff\1\7\10\uffff\1\3\1\4\1\5\1\6\2\uffff\1\7", | ||
6980 | "\1\10", | ||
6981 | "\1\10\12\uffff\1\11", | ||
6982 | "\1\10\12\uffff\1\11", | ||
6983 | "\1\10\12\uffff\1\11", | ||
6984 | "\1\10\12\uffff\1\11", | ||
6985 | "\1\10\12\uffff\1\11", | ||
6986 | "", | ||
6987 | "\1\22\1\13\1\21\1\12\26\uffff\1\23\12\uffff\1\14\1\15\1\16\1\17\1\20", | ||
6988 | "\1\24\1\uffff\1\31\41\uffff\1\25\1\26\1\27\1\30", | ||
6989 | "\1\32\14\uffff\1\23", | ||
6990 | "\1\32\14\uffff\1\23\11\uffff\1\33", | ||
6991 | "\1\32\14\uffff\1\23\11\uffff\1\33", | ||
6992 | "\1\32\14\uffff\1\23\11\uffff\1\33", | ||
6993 | "\1\32\14\uffff\1\23\11\uffff\1\33", | ||
6994 | "\1\32\14\uffff\1\23\11\uffff\1\33", | ||
6995 | "\1\21", | ||
6996 | "\1\34\3\uffff\1\32\14\uffff\1\23\14\uffff\1\35\1\36", | ||
6997 | "\1\32\14\uffff\1\23", | ||
6998 | "\1\7\24\uffff\1\37", | ||
6999 | "\1\10\12\uffff\1\11", | ||
7000 | "\1\10\12\uffff\1\11", | ||
7001 | "\1\10\12\uffff\1\11", | ||
7002 | "\1\10\12\uffff\1\11", | ||
7003 | "\1\10\12\uffff\1\11", | ||
7004 | "\1\10", | ||
7005 | "\1\50\1\41\1\47\1\40\41\uffff\1\42\1\43\1\44\1\45\1\46", | ||
7006 | "\1\51\1\uffff\1\56\41\uffff\1\52\1\53\1\54\1\55", | ||
7007 | "\1\57", | ||
7008 | "\1\62\32\uffff\1\61\13\uffff\1\60", | ||
7009 | "\1\62\32\uffff\1\61\13\uffff\1\60", | ||
7010 | "", | ||
7011 | "\1\32\14\uffff\1\23", | ||
7012 | "\1\32\14\uffff\1\23\11\uffff\1\63", | ||
7013 | "\1\32\14\uffff\1\23\11\uffff\1\63", | ||
7014 | "\1\32\14\uffff\1\23\11\uffff\1\63", | ||
7015 | "\1\32\14\uffff\1\23\11\uffff\1\63", | ||
7016 | "\1\32\14\uffff\1\23\11\uffff\1\63", | ||
7017 | "\1\47", | ||
7018 | "\1\64\3\uffff\1\32\14\uffff\1\23\14\uffff\1\65\1\66", | ||
7019 | "\1\32\14\uffff\1\23", | ||
7020 | "\1\32\14\uffff\1\23\11\uffff\1\33", | ||
7021 | "\1\32\14\uffff\1\23\11\uffff\1\33", | ||
7022 | "\1\32\14\uffff\1\23\11\uffff\1\33", | ||
7023 | "\1\32\14\uffff\1\23\11\uffff\1\33", | ||
7024 | "\1\32\14\uffff\1\23\11\uffff\1\33", | ||
7025 | "\1\32\14\uffff\1\23", | ||
7026 | "\1\32\14\uffff\1\23\14\uffff\1\35\1\36", | ||
7027 | "\1\62", | ||
7028 | "\1\62", | ||
7029 | "\1\32\14\uffff\1\23", | ||
7030 | "\1\67\1\uffff\1\74\41\uffff\1\70\1\71\1\72\1\73", | ||
7031 | "\1\75", | ||
7032 | "\1\100\32\uffff\1\77\13\uffff\1\76", | ||
7033 | "\1\100\32\uffff\1\77\13\uffff\1\76", | ||
7034 | "\1\32\14\uffff\1\23\11\uffff\1\63", | ||
7035 | "\1\32\14\uffff\1\23\11\uffff\1\63", | ||
7036 | "\1\32\14\uffff\1\23\11\uffff\1\63", | ||
7037 | "\1\32\14\uffff\1\23\11\uffff\1\63", | ||
7038 | "\1\32\14\uffff\1\23\11\uffff\1\63", | ||
7039 | "\1\32\14\uffff\1\23", | ||
7040 | "\1\32\14\uffff\1\23\14\uffff\1\65\1\66", | ||
7041 | "\1\100", | ||
7042 | "\1\100", | ||
7043 | "\1\32\14\uffff\1\23" | ||
7044 | }; | ||
7045 | |||
7046 | static final short[] dfa_7 = DFA.unpackEncodedString(dfa_7s); | ||
7047 | static final char[] dfa_8 = DFA.unpackEncodedStringToUnsignedChars(dfa_8s); | ||
7048 | static final char[] dfa_9 = DFA.unpackEncodedStringToUnsignedChars(dfa_9s); | ||
7049 | static final short[] dfa_10 = DFA.unpackEncodedString(dfa_10s); | ||
7050 | static final short[] dfa_11 = DFA.unpackEncodedString(dfa_11s); | ||
7051 | static final short[][] dfa_12 = unpackEncodedStringArray(dfa_12s); | ||
7052 | |||
7053 | class DFA35 extends DFA { | ||
7054 | |||
7055 | public DFA35(BaseRecognizer recognizer) { | ||
7056 | this.recognizer = recognizer; | ||
7057 | this.decisionNumber = 35; | ||
7058 | this.eot = dfa_7; | ||
7059 | this.eof = dfa_7; | ||
7060 | this.min = dfa_8; | ||
7061 | this.max = dfa_9; | ||
7062 | this.accept = dfa_10; | ||
7063 | this.special = dfa_11; | ||
7064 | this.transition = dfa_12; | ||
7065 | } | ||
7066 | public String getDescription() { | ||
7067 | return "1219:3: ( ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( (lv_arguments_2_0= ruleAssertionArgument ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleAssertionArgument ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) | ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( (lv_arguments_11_0= ruleAssertionArgument ) ) (otherlv_12= ',' ( (lv_arguments_13_0= ruleAssertionArgument ) ) )* )? otherlv_14= ')' ) )"; | ||
5255 | } | 7068 | } |
5256 | } | 7069 | } |
5257 | 7070 | ||
5258 | 7071 | ||
5259 | public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L}); | 7072 | public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L}); |
5260 | public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L}); | 7073 | public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L}); |
5261 | public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000060000000010L}); | 7074 | public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x00001E0000000020L}); |
5262 | public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000002000L}); | 7075 | public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000002000L}); |
5263 | public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x000016091820C052L}); | 7076 | public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x00009E091820C0A2L}); |
5264 | public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000008000L}); | 7077 | public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000008000L}); |
5265 | public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000052000L}); | 7078 | public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000052000L}); |
5266 | public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000060000000050L}); | 7079 | public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x00001E00000000A0L}); |
5267 | public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000062000L}); | 7080 | public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000062000L}); |
5268 | public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000060000D00050L}); | 7081 | public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x00001E0000D000A0L}); |
5269 | public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000060000D80050L}); | 7082 | public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x00001E0000D800A0L}); |
5270 | public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000042000L}); | 7083 | public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000042000L}); |
5271 | public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000060000100050L}); | 7084 | public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x00001E00001000A0L}); |
5272 | public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x00000000001A0000L}); | 7085 | public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x00000000001A0000L}); |
5273 | public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000000100000L}); | 7086 | public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000000100000L}); |
5274 | public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000060001000010L}); | 7087 | public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x00001E0001000020L}); |
5275 | public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000000000020L}); | 7088 | public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000000000040L}); |
5276 | public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000002000000L}); | 7089 | public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000002000000L}); |
5277 | public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000004000002L}); | 7090 | public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000004000002L}); |
5278 | public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000060010000010L}); | 7091 | public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x00001E0010000020L}); |
5279 | public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000020000000L}); | 7092 | public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000020000000L}); |
5280 | public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000060040000050L}); | 7093 | public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x00001E00400000A0L}); |
5281 | public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000040020000L}); | 7094 | public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000040020000L}); |
5282 | public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000080002000L}); | 7095 | public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000080002000L}); |
5283 | public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000060100000050L}); | 7096 | public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x00001E01000000A0L}); |
5284 | public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000000082000L}); | 7097 | public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000000082000L}); |
5285 | public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000000020002L}); | 7098 | public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000000020002L}); |
5286 | public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000220000000L}); | 7099 | public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000220000000L}); |
5287 | public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000400000000L}); | 7100 | public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x00003E00400000F0L}); |
5288 | public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x00000E0000000000L}); | 7101 | public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x00003E00000000F0L}); |
5289 | public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000000000000010L}); | 7102 | public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000000400000000L}); |
5290 | public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000000000022000L}); | 7103 | public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000460000000000L}); |
5291 | public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000003000000000L}); | 7104 | public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000000000000020L}); |
5292 | public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000004000000000L}); | 7105 | public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000000000022000L}); |
5293 | public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000008000000020L}); | 7106 | public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000003000000000L}); |
5294 | public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000010000000002L}); | 7107 | public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000004000000000L}); |
5295 | public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000000000000040L}); | 7108 | public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000008000000040L}); |
7109 | public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000010000000002L}); | ||
7110 | public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000000000000080L}); | ||
7111 | public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000180000002000L}); | ||
7112 | public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000180000000000L}); | ||
7113 | public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000200200000040L}); | ||
5296 | 7114 | ||
5297 | } \ No newline at end of file | 7115 | } \ No newline at end of file |
diff --git a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/serializer/ProblemSemanticSequencer.java b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/serializer/ProblemSemanticSequencer.java index cb44c31f..012363db 100644 --- a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/serializer/ProblemSemanticSequencer.java +++ b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/serializer/ProblemSemanticSequencer.java | |||
@@ -7,23 +7,30 @@ import com.google.inject.Inject; | |||
7 | import java.util.Set; | 7 | import java.util.Set; |
8 | import org.eclipse.emf.ecore.EObject; | 8 | import org.eclipse.emf.ecore.EObject; |
9 | import org.eclipse.emf.ecore.EPackage; | 9 | import org.eclipse.emf.ecore.EPackage; |
10 | import org.eclipse.viatra.solver.language.model.problem.Argument; | ||
11 | import org.eclipse.viatra.solver.language.model.problem.Assertion; | 10 | import org.eclipse.viatra.solver.language.model.problem.Assertion; |
12 | import org.eclipse.viatra.solver.language.model.problem.Atom; | 11 | import org.eclipse.viatra.solver.language.model.problem.Atom; |
13 | import org.eclipse.viatra.solver.language.model.problem.ClassDeclaration; | 12 | import org.eclipse.viatra.solver.language.model.problem.ClassDeclaration; |
14 | import org.eclipse.viatra.solver.language.model.problem.Conjunction; | 13 | import org.eclipse.viatra.solver.language.model.problem.Conjunction; |
14 | import org.eclipse.viatra.solver.language.model.problem.ConstantArgument; | ||
15 | import org.eclipse.viatra.solver.language.model.problem.ConstantAssertionArgument; | ||
15 | import org.eclipse.viatra.solver.language.model.problem.EnumDeclaration; | 16 | import org.eclipse.viatra.solver.language.model.problem.EnumDeclaration; |
16 | import org.eclipse.viatra.solver.language.model.problem.ExactMultiplicity; | 17 | import org.eclipse.viatra.solver.language.model.problem.ExactMultiplicity; |
18 | import org.eclipse.viatra.solver.language.model.problem.IntConstant; | ||
17 | import org.eclipse.viatra.solver.language.model.problem.NegativeLiteral; | 19 | import org.eclipse.viatra.solver.language.model.problem.NegativeLiteral; |
18 | import org.eclipse.viatra.solver.language.model.problem.Node; | 20 | import org.eclipse.viatra.solver.language.model.problem.Node; |
21 | import org.eclipse.viatra.solver.language.model.problem.NodeAssertionArgument; | ||
22 | import org.eclipse.viatra.solver.language.model.problem.NodeValueAssertion; | ||
19 | import org.eclipse.viatra.solver.language.model.problem.PredicateDefinition; | 23 | import org.eclipse.viatra.solver.language.model.problem.PredicateDefinition; |
20 | import org.eclipse.viatra.solver.language.model.problem.Problem; | 24 | import org.eclipse.viatra.solver.language.model.problem.Problem; |
21 | import org.eclipse.viatra.solver.language.model.problem.ProblemPackage; | 25 | import org.eclipse.viatra.solver.language.model.problem.ProblemPackage; |
22 | import org.eclipse.viatra.solver.language.model.problem.RangeMultiplicity; | 26 | import org.eclipse.viatra.solver.language.model.problem.RangeMultiplicity; |
27 | import org.eclipse.viatra.solver.language.model.problem.RealConstant; | ||
23 | import org.eclipse.viatra.solver.language.model.problem.ReferenceDeclaration; | 28 | import org.eclipse.viatra.solver.language.model.problem.ReferenceDeclaration; |
24 | import org.eclipse.viatra.solver.language.model.problem.ScopeDeclaration; | 29 | import org.eclipse.viatra.solver.language.model.problem.ScopeDeclaration; |
30 | import org.eclipse.viatra.solver.language.model.problem.StringConstant; | ||
25 | import org.eclipse.viatra.solver.language.model.problem.TypeScope; | 31 | import org.eclipse.viatra.solver.language.model.problem.TypeScope; |
26 | import org.eclipse.viatra.solver.language.model.problem.UnboundedMultiplicity; | 32 | import org.eclipse.viatra.solver.language.model.problem.UnboundedMultiplicity; |
33 | import org.eclipse.viatra.solver.language.model.problem.VariableOrNodeArgument; | ||
27 | import org.eclipse.viatra.solver.language.services.ProblemGrammarAccess; | 34 | import org.eclipse.viatra.solver.language.services.ProblemGrammarAccess; |
28 | import org.eclipse.xtext.Action; | 35 | import org.eclipse.xtext.Action; |
29 | import org.eclipse.xtext.Parameter; | 36 | import org.eclipse.xtext.Parameter; |
@@ -47,9 +54,6 @@ public class ProblemSemanticSequencer extends AbstractDelegatingSemanticSequence | |||
47 | Set<Parameter> parameters = context.getEnabledBooleanParameters(); | 54 | Set<Parameter> parameters = context.getEnabledBooleanParameters(); |
48 | if (epackage == ProblemPackage.eINSTANCE) | 55 | if (epackage == ProblemPackage.eINSTANCE) |
49 | switch (semanticObject.eClass().getClassifierID()) { | 56 | switch (semanticObject.eClass().getClassifierID()) { |
50 | case ProblemPackage.ARGUMENT: | ||
51 | sequence_Argument(context, (Argument) semanticObject); | ||
52 | return; | ||
53 | case ProblemPackage.ASSERTION: | 57 | case ProblemPackage.ASSERTION: |
54 | sequence_Assertion(context, (Assertion) semanticObject); | 58 | sequence_Assertion(context, (Assertion) semanticObject); |
55 | return; | 59 | return; |
@@ -62,18 +66,33 @@ public class ProblemSemanticSequencer extends AbstractDelegatingSemanticSequence | |||
62 | case ProblemPackage.CONJUNCTION: | 66 | case ProblemPackage.CONJUNCTION: |
63 | sequence_Conjunction(context, (Conjunction) semanticObject); | 67 | sequence_Conjunction(context, (Conjunction) semanticObject); |
64 | return; | 68 | return; |
69 | case ProblemPackage.CONSTANT_ARGUMENT: | ||
70 | sequence_ConstantArgument(context, (ConstantArgument) semanticObject); | ||
71 | return; | ||
72 | case ProblemPackage.CONSTANT_ASSERTION_ARGUMENT: | ||
73 | sequence_ConstantAssertionArgument(context, (ConstantAssertionArgument) semanticObject); | ||
74 | return; | ||
65 | case ProblemPackage.ENUM_DECLARATION: | 75 | case ProblemPackage.ENUM_DECLARATION: |
66 | sequence_EnumDeclaration(context, (EnumDeclaration) semanticObject); | 76 | sequence_EnumDeclaration(context, (EnumDeclaration) semanticObject); |
67 | return; | 77 | return; |
68 | case ProblemPackage.EXACT_MULTIPLICITY: | 78 | case ProblemPackage.EXACT_MULTIPLICITY: |
69 | sequence_ExactMultiplicity(context, (ExactMultiplicity) semanticObject); | 79 | sequence_ExactMultiplicity(context, (ExactMultiplicity) semanticObject); |
70 | return; | 80 | return; |
81 | case ProblemPackage.INT_CONSTANT: | ||
82 | sequence_IntConstant(context, (IntConstant) semanticObject); | ||
83 | return; | ||
71 | case ProblemPackage.NEGATIVE_LITERAL: | 84 | case ProblemPackage.NEGATIVE_LITERAL: |
72 | sequence_NegativeLiteral(context, (NegativeLiteral) semanticObject); | 85 | sequence_NegativeLiteral(context, (NegativeLiteral) semanticObject); |
73 | return; | 86 | return; |
74 | case ProblemPackage.NODE: | 87 | case ProblemPackage.NODE: |
75 | sequence_EnumLiteral(context, (Node) semanticObject); | 88 | sequence_EnumLiteral(context, (Node) semanticObject); |
76 | return; | 89 | return; |
90 | case ProblemPackage.NODE_ASSERTION_ARGUMENT: | ||
91 | sequence_NodeAssertionArgument(context, (NodeAssertionArgument) semanticObject); | ||
92 | return; | ||
93 | case ProblemPackage.NODE_VALUE_ASSERTION: | ||
94 | sequence_NodeValueAssertion(context, (NodeValueAssertion) semanticObject); | ||
95 | return; | ||
77 | case ProblemPackage.PARAMETER: | 96 | case ProblemPackage.PARAMETER: |
78 | sequence_Parameter(context, (org.eclipse.viatra.solver.language.model.problem.Parameter) semanticObject); | 97 | sequence_Parameter(context, (org.eclipse.viatra.solver.language.model.problem.Parameter) semanticObject); |
79 | return; | 98 | return; |
@@ -86,18 +105,27 @@ public class ProblemSemanticSequencer extends AbstractDelegatingSemanticSequence | |||
86 | case ProblemPackage.RANGE_MULTIPLICITY: | 105 | case ProblemPackage.RANGE_MULTIPLICITY: |
87 | sequence_RangeMultiplicity(context, (RangeMultiplicity) semanticObject); | 106 | sequence_RangeMultiplicity(context, (RangeMultiplicity) semanticObject); |
88 | return; | 107 | return; |
108 | case ProblemPackage.REAL_CONSTANT: | ||
109 | sequence_RealConstant(context, (RealConstant) semanticObject); | ||
110 | return; | ||
89 | case ProblemPackage.REFERENCE_DECLARATION: | 111 | case ProblemPackage.REFERENCE_DECLARATION: |
90 | sequence_ReferenceDeclaration(context, (ReferenceDeclaration) semanticObject); | 112 | sequence_ReferenceDeclaration(context, (ReferenceDeclaration) semanticObject); |
91 | return; | 113 | return; |
92 | case ProblemPackage.SCOPE_DECLARATION: | 114 | case ProblemPackage.SCOPE_DECLARATION: |
93 | sequence_ScopeDeclaration(context, (ScopeDeclaration) semanticObject); | 115 | sequence_ScopeDeclaration(context, (ScopeDeclaration) semanticObject); |
94 | return; | 116 | return; |
117 | case ProblemPackage.STRING_CONSTANT: | ||
118 | sequence_StringConstant(context, (StringConstant) semanticObject); | ||
119 | return; | ||
95 | case ProblemPackage.TYPE_SCOPE: | 120 | case ProblemPackage.TYPE_SCOPE: |
96 | sequence_TypeScope(context, (TypeScope) semanticObject); | 121 | sequence_TypeScope(context, (TypeScope) semanticObject); |
97 | return; | 122 | return; |
98 | case ProblemPackage.UNBOUNDED_MULTIPLICITY: | 123 | case ProblemPackage.UNBOUNDED_MULTIPLICITY: |
99 | sequence_UnboundedMultiplicity(context, (UnboundedMultiplicity) semanticObject); | 124 | sequence_UnboundedMultiplicity(context, (UnboundedMultiplicity) semanticObject); |
100 | return; | 125 | return; |
126 | case ProblemPackage.VARIABLE_OR_NODE_ARGUMENT: | ||
127 | sequence_VariableOrNodeArgument(context, (VariableOrNodeArgument) semanticObject); | ||
128 | return; | ||
101 | } | 129 | } |
102 | if (errorAcceptor != null) | 130 | if (errorAcceptor != null) |
103 | errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context)); | 131 | errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context)); |
@@ -105,31 +133,13 @@ public class ProblemSemanticSequencer extends AbstractDelegatingSemanticSequence | |||
105 | 133 | ||
106 | /** | 134 | /** |
107 | * Contexts: | 135 | * Contexts: |
108 | * Argument returns Argument | ||
109 | * | ||
110 | * Constraint: | ||
111 | * variableOrNode=[VariableOrNode|QualifiedName] | ||
112 | */ | ||
113 | protected void sequence_Argument(ISerializationContext context, Argument semanticObject) { | ||
114 | if (errorAcceptor != null) { | ||
115 | if (transientValues.isValueTransient(semanticObject, ProblemPackage.Literals.ARGUMENT__VARIABLE_OR_NODE) == ValueTransient.YES) | ||
116 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ProblemPackage.Literals.ARGUMENT__VARIABLE_OR_NODE)); | ||
117 | } | ||
118 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
119 | feeder.accept(grammarAccess.getArgumentAccess().getVariableOrNodeVariableOrNodeQualifiedNameParserRuleCall_0_1(), semanticObject.eGet(ProblemPackage.Literals.ARGUMENT__VARIABLE_OR_NODE, false)); | ||
120 | feeder.finish(); | ||
121 | } | ||
122 | |||
123 | |||
124 | /** | ||
125 | * Contexts: | ||
126 | * Statement returns Assertion | 136 | * Statement returns Assertion |
127 | * Assertion returns Assertion | 137 | * Assertion returns Assertion |
128 | * | 138 | * |
129 | * Constraint: | 139 | * Constraint: |
130 | * ( | 140 | * ( |
131 | * (relation=[Relation|QualifiedName] (arguments+=[Node|QualifiedName] arguments+=[Node|QualifiedName]*)? value=LogicValue) | | 141 | * (relation=[Relation|QualifiedName] (arguments+=AssertionArgument arguments+=AssertionArgument*)? value=LogicValue) | |
132 | * (value=ShortLogicValue? relation=[Relation|QualifiedName] (arguments+=[Node|QualifiedName] arguments+=[Node|QualifiedName]*)?) | 142 | * (value=ShortLogicValue? relation=[Relation|QualifiedName] (arguments+=AssertionArgument arguments+=AssertionArgument*)?) |
133 | * ) | 143 | * ) |
134 | */ | 144 | */ |
135 | protected void sequence_Assertion(ISerializationContext context, Assertion semanticObject) { | 145 | protected void sequence_Assertion(ISerializationContext context, Assertion semanticObject) { |
@@ -182,6 +192,44 @@ public class ProblemSemanticSequencer extends AbstractDelegatingSemanticSequence | |||
182 | 192 | ||
183 | /** | 193 | /** |
184 | * Contexts: | 194 | * Contexts: |
195 | * Argument returns ConstantArgument | ||
196 | * ConstantArgument returns ConstantArgument | ||
197 | * | ||
198 | * Constraint: | ||
199 | * constant=Constant | ||
200 | */ | ||
201 | protected void sequence_ConstantArgument(ISerializationContext context, ConstantArgument semanticObject) { | ||
202 | if (errorAcceptor != null) { | ||
203 | if (transientValues.isValueTransient(semanticObject, ProblemPackage.Literals.CONSTANT_ARGUMENT__CONSTANT) == ValueTransient.YES) | ||
204 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ProblemPackage.Literals.CONSTANT_ARGUMENT__CONSTANT)); | ||
205 | } | ||
206 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
207 | feeder.accept(grammarAccess.getConstantArgumentAccess().getConstantConstantParserRuleCall_0(), semanticObject.getConstant()); | ||
208 | feeder.finish(); | ||
209 | } | ||
210 | |||
211 | |||
212 | /** | ||
213 | * Contexts: | ||
214 | * AssertionArgument returns ConstantAssertionArgument | ||
215 | * ConstantAssertionArgument returns ConstantAssertionArgument | ||
216 | * | ||
217 | * Constraint: | ||
218 | * constant=Constant | ||
219 | */ | ||
220 | protected void sequence_ConstantAssertionArgument(ISerializationContext context, ConstantAssertionArgument semanticObject) { | ||
221 | if (errorAcceptor != null) { | ||
222 | if (transientValues.isValueTransient(semanticObject, ProblemPackage.Literals.CONSTANT_ASSERTION_ARGUMENT__CONSTANT) == ValueTransient.YES) | ||
223 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ProblemPackage.Literals.CONSTANT_ASSERTION_ARGUMENT__CONSTANT)); | ||
224 | } | ||
225 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
226 | feeder.accept(grammarAccess.getConstantAssertionArgumentAccess().getConstantConstantParserRuleCall_0(), semanticObject.getConstant()); | ||
227 | feeder.finish(); | ||
228 | } | ||
229 | |||
230 | |||
231 | /** | ||
232 | * Contexts: | ||
185 | * Statement returns EnumDeclaration | 233 | * Statement returns EnumDeclaration |
186 | * EnumDeclaration returns EnumDeclaration | 234 | * EnumDeclaration returns EnumDeclaration |
187 | * | 235 | * |
@@ -233,6 +281,25 @@ public class ProblemSemanticSequencer extends AbstractDelegatingSemanticSequence | |||
233 | 281 | ||
234 | /** | 282 | /** |
235 | * Contexts: | 283 | * Contexts: |
284 | * Constant returns IntConstant | ||
285 | * IntConstant returns IntConstant | ||
286 | * | ||
287 | * Constraint: | ||
288 | * intValue=Integer | ||
289 | */ | ||
290 | protected void sequence_IntConstant(ISerializationContext context, IntConstant semanticObject) { | ||
291 | if (errorAcceptor != null) { | ||
292 | if (transientValues.isValueTransient(semanticObject, ProblemPackage.Literals.INT_CONSTANT__INT_VALUE) == ValueTransient.YES) | ||
293 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ProblemPackage.Literals.INT_CONSTANT__INT_VALUE)); | ||
294 | } | ||
295 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
296 | feeder.accept(grammarAccess.getIntConstantAccess().getIntValueIntegerParserRuleCall_0(), semanticObject.getIntValue()); | ||
297 | feeder.finish(); | ||
298 | } | ||
299 | |||
300 | |||
301 | /** | ||
302 | * Contexts: | ||
236 | * Literal returns NegativeLiteral | 303 | * Literal returns NegativeLiteral |
237 | * NegativeLiteral returns NegativeLiteral | 304 | * NegativeLiteral returns NegativeLiteral |
238 | * | 305 | * |
@@ -252,6 +319,47 @@ public class ProblemSemanticSequencer extends AbstractDelegatingSemanticSequence | |||
252 | 319 | ||
253 | /** | 320 | /** |
254 | * Contexts: | 321 | * Contexts: |
322 | * AssertionArgument returns NodeAssertionArgument | ||
323 | * NodeAssertionArgument returns NodeAssertionArgument | ||
324 | * | ||
325 | * Constraint: | ||
326 | * node=[Node|QualifiedName] | ||
327 | */ | ||
328 | protected void sequence_NodeAssertionArgument(ISerializationContext context, NodeAssertionArgument semanticObject) { | ||
329 | if (errorAcceptor != null) { | ||
330 | if (transientValues.isValueTransient(semanticObject, ProblemPackage.Literals.NODE_ASSERTION_ARGUMENT__NODE) == ValueTransient.YES) | ||
331 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ProblemPackage.Literals.NODE_ASSERTION_ARGUMENT__NODE)); | ||
332 | } | ||
333 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
334 | feeder.accept(grammarAccess.getNodeAssertionArgumentAccess().getNodeNodeQualifiedNameParserRuleCall_0_1(), semanticObject.eGet(ProblemPackage.Literals.NODE_ASSERTION_ARGUMENT__NODE, false)); | ||
335 | feeder.finish(); | ||
336 | } | ||
337 | |||
338 | |||
339 | /** | ||
340 | * Contexts: | ||
341 | * Statement returns NodeValueAssertion | ||
342 | * NodeValueAssertion returns NodeValueAssertion | ||
343 | * | ||
344 | * Constraint: | ||
345 | * (node=[Node|QualifiedName] value=Constant) | ||
346 | */ | ||
347 | protected void sequence_NodeValueAssertion(ISerializationContext context, NodeValueAssertion semanticObject) { | ||
348 | if (errorAcceptor != null) { | ||
349 | if (transientValues.isValueTransient(semanticObject, ProblemPackage.Literals.NODE_VALUE_ASSERTION__NODE) == ValueTransient.YES) | ||
350 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ProblemPackage.Literals.NODE_VALUE_ASSERTION__NODE)); | ||
351 | if (transientValues.isValueTransient(semanticObject, ProblemPackage.Literals.NODE_VALUE_ASSERTION__VALUE) == ValueTransient.YES) | ||
352 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ProblemPackage.Literals.NODE_VALUE_ASSERTION__VALUE)); | ||
353 | } | ||
354 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
355 | feeder.accept(grammarAccess.getNodeValueAssertionAccess().getNodeNodeQualifiedNameParserRuleCall_0_0_1(), semanticObject.eGet(ProblemPackage.Literals.NODE_VALUE_ASSERTION__NODE, false)); | ||
356 | feeder.accept(grammarAccess.getNodeValueAssertionAccess().getValueConstantParserRuleCall_2_0(), semanticObject.getValue()); | ||
357 | feeder.finish(); | ||
358 | } | ||
359 | |||
360 | |||
361 | /** | ||
362 | * Contexts: | ||
255 | * Parameter returns Parameter | 363 | * Parameter returns Parameter |
256 | * | 364 | * |
257 | * Constraint: | 365 | * Constraint: |
@@ -312,6 +420,25 @@ public class ProblemSemanticSequencer extends AbstractDelegatingSemanticSequence | |||
312 | 420 | ||
313 | /** | 421 | /** |
314 | * Contexts: | 422 | * Contexts: |
423 | * Constant returns RealConstant | ||
424 | * RealConstant returns RealConstant | ||
425 | * | ||
426 | * Constraint: | ||
427 | * realValue=Real | ||
428 | */ | ||
429 | protected void sequence_RealConstant(ISerializationContext context, RealConstant semanticObject) { | ||
430 | if (errorAcceptor != null) { | ||
431 | if (transientValues.isValueTransient(semanticObject, ProblemPackage.Literals.REAL_CONSTANT__REAL_VALUE) == ValueTransient.YES) | ||
432 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ProblemPackage.Literals.REAL_CONSTANT__REAL_VALUE)); | ||
433 | } | ||
434 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
435 | feeder.accept(grammarAccess.getRealConstantAccess().getRealValueRealParserRuleCall_0(), semanticObject.getRealValue()); | ||
436 | feeder.finish(); | ||
437 | } | ||
438 | |||
439 | |||
440 | /** | ||
441 | * Contexts: | ||
315 | * ReferenceDeclaration returns ReferenceDeclaration | 442 | * ReferenceDeclaration returns ReferenceDeclaration |
316 | * | 443 | * |
317 | * Constraint: | 444 | * Constraint: |
@@ -343,6 +470,25 @@ public class ProblemSemanticSequencer extends AbstractDelegatingSemanticSequence | |||
343 | 470 | ||
344 | /** | 471 | /** |
345 | * Contexts: | 472 | * Contexts: |
473 | * Constant returns StringConstant | ||
474 | * StringConstant returns StringConstant | ||
475 | * | ||
476 | * Constraint: | ||
477 | * stringValue=STRING | ||
478 | */ | ||
479 | protected void sequence_StringConstant(ISerializationContext context, StringConstant semanticObject) { | ||
480 | if (errorAcceptor != null) { | ||
481 | if (transientValues.isValueTransient(semanticObject, ProblemPackage.Literals.STRING_CONSTANT__STRING_VALUE) == ValueTransient.YES) | ||
482 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ProblemPackage.Literals.STRING_CONSTANT__STRING_VALUE)); | ||
483 | } | ||
484 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
485 | feeder.accept(grammarAccess.getStringConstantAccess().getStringValueSTRINGTerminalRuleCall_0(), semanticObject.getStringValue()); | ||
486 | feeder.finish(); | ||
487 | } | ||
488 | |||
489 | |||
490 | /** | ||
491 | * Contexts: | ||
346 | * TypeScope returns TypeScope | 492 | * TypeScope returns TypeScope |
347 | * | 493 | * |
348 | * Constraint: | 494 | * Constraint: |
@@ -366,4 +512,23 @@ public class ProblemSemanticSequencer extends AbstractDelegatingSemanticSequence | |||
366 | } | 512 | } |
367 | 513 | ||
368 | 514 | ||
515 | /** | ||
516 | * Contexts: | ||
517 | * Argument returns VariableOrNodeArgument | ||
518 | * VariableOrNodeArgument returns VariableOrNodeArgument | ||
519 | * | ||
520 | * Constraint: | ||
521 | * variableOrNode=[VariableOrNode|QualifiedName] | ||
522 | */ | ||
523 | protected void sequence_VariableOrNodeArgument(ISerializationContext context, VariableOrNodeArgument semanticObject) { | ||
524 | if (errorAcceptor != null) { | ||
525 | if (transientValues.isValueTransient(semanticObject, ProblemPackage.Literals.VARIABLE_OR_NODE_ARGUMENT__VARIABLE_OR_NODE) == ValueTransient.YES) | ||
526 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ProblemPackage.Literals.VARIABLE_OR_NODE_ARGUMENT__VARIABLE_OR_NODE)); | ||
527 | } | ||
528 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
529 | feeder.accept(grammarAccess.getVariableOrNodeArgumentAccess().getVariableOrNodeVariableOrNodeQualifiedNameParserRuleCall_0_1(), semanticObject.eGet(ProblemPackage.Literals.VARIABLE_OR_NODE_ARGUMENT__VARIABLE_OR_NODE, false)); | ||
530 | feeder.finish(); | ||
531 | } | ||
532 | |||
533 | |||
369 | } | 534 | } |
diff --git a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/services/ProblemGrammarAccess.java b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/services/ProblemGrammarAccess.java index 13f92444..2cb37dbc 100644 --- a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/services/ProblemGrammarAccess.java +++ b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/services/ProblemGrammarAccess.java | |||
@@ -74,13 +74,14 @@ public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarE | |||
74 | private final RuleCall cEnumDeclarationParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | 74 | private final RuleCall cEnumDeclarationParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); |
75 | private final RuleCall cPredicateDefinitionParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); | 75 | private final RuleCall cPredicateDefinitionParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); |
76 | private final RuleCall cAssertionParserRuleCall_3 = (RuleCall)cAlternatives.eContents().get(3); | 76 | private final RuleCall cAssertionParserRuleCall_3 = (RuleCall)cAlternatives.eContents().get(3); |
77 | private final RuleCall cScopeDeclarationParserRuleCall_4 = (RuleCall)cAlternatives.eContents().get(4); | 77 | private final RuleCall cNodeValueAssertionParserRuleCall_4 = (RuleCall)cAlternatives.eContents().get(4); |
78 | private final RuleCall cScopeDeclarationParserRuleCall_5 = (RuleCall)cAlternatives.eContents().get(5); | ||
78 | 79 | ||
79 | //Statement: | 80 | //Statement: |
80 | // ClassDeclaration | EnumDeclaration | PredicateDefinition | Assertion | ScopeDeclaration; | 81 | // ClassDeclaration | EnumDeclaration | PredicateDefinition | Assertion | NodeValueAssertion | ScopeDeclaration; |
81 | @Override public ParserRule getRule() { return rule; } | 82 | @Override public ParserRule getRule() { return rule; } |
82 | 83 | ||
83 | //ClassDeclaration | EnumDeclaration | PredicateDefinition | Assertion | ScopeDeclaration | 84 | //ClassDeclaration | EnumDeclaration | PredicateDefinition | Assertion | NodeValueAssertion | ScopeDeclaration |
84 | public Alternatives getAlternatives() { return cAlternatives; } | 85 | public Alternatives getAlternatives() { return cAlternatives; } |
85 | 86 | ||
86 | //ClassDeclaration | 87 | //ClassDeclaration |
@@ -95,8 +96,11 @@ public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarE | |||
95 | //Assertion | 96 | //Assertion |
96 | public RuleCall getAssertionParserRuleCall_3() { return cAssertionParserRuleCall_3; } | 97 | public RuleCall getAssertionParserRuleCall_3() { return cAssertionParserRuleCall_3; } |
97 | 98 | ||
99 | //NodeValueAssertion | ||
100 | public RuleCall getNodeValueAssertionParserRuleCall_4() { return cNodeValueAssertionParserRuleCall_4; } | ||
101 | |||
98 | //ScopeDeclaration | 102 | //ScopeDeclaration |
99 | public RuleCall getScopeDeclarationParserRuleCall_4() { return cScopeDeclarationParserRuleCall_4; } | 103 | public RuleCall getScopeDeclarationParserRuleCall_5() { return cScopeDeclarationParserRuleCall_5; } |
100 | } | 104 | } |
101 | public class ClassDeclarationElements extends AbstractParserRuleElementFinder { | 105 | public class ClassDeclarationElements extends AbstractParserRuleElementFinder { |
102 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.ClassDeclaration"); | 106 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.ClassDeclaration"); |
@@ -712,11 +716,30 @@ public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarE | |||
712 | } | 716 | } |
713 | public class ArgumentElements extends AbstractParserRuleElementFinder { | 717 | public class ArgumentElements extends AbstractParserRuleElementFinder { |
714 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.Argument"); | 718 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.Argument"); |
719 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
720 | private final RuleCall cVariableOrNodeArgumentParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | ||
721 | private final RuleCall cConstantArgumentParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | ||
722 | |||
723 | //Argument: | ||
724 | // VariableOrNodeArgument | ConstantArgument; | ||
725 | @Override public ParserRule getRule() { return rule; } | ||
726 | |||
727 | //VariableOrNodeArgument | ConstantArgument | ||
728 | public Alternatives getAlternatives() { return cAlternatives; } | ||
729 | |||
730 | //VariableOrNodeArgument | ||
731 | public RuleCall getVariableOrNodeArgumentParserRuleCall_0() { return cVariableOrNodeArgumentParserRuleCall_0; } | ||
732 | |||
733 | //ConstantArgument | ||
734 | public RuleCall getConstantArgumentParserRuleCall_1() { return cConstantArgumentParserRuleCall_1; } | ||
735 | } | ||
736 | public class VariableOrNodeArgumentElements extends AbstractParserRuleElementFinder { | ||
737 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.VariableOrNodeArgument"); | ||
715 | private final Assignment cVariableOrNodeAssignment = (Assignment)rule.eContents().get(1); | 738 | private final Assignment cVariableOrNodeAssignment = (Assignment)rule.eContents().get(1); |
716 | private final CrossReference cVariableOrNodeVariableOrNodeCrossReference_0 = (CrossReference)cVariableOrNodeAssignment.eContents().get(0); | 739 | private final CrossReference cVariableOrNodeVariableOrNodeCrossReference_0 = (CrossReference)cVariableOrNodeAssignment.eContents().get(0); |
717 | private final RuleCall cVariableOrNodeVariableOrNodeQualifiedNameParserRuleCall_0_1 = (RuleCall)cVariableOrNodeVariableOrNodeCrossReference_0.eContents().get(1); | 740 | private final RuleCall cVariableOrNodeVariableOrNodeQualifiedNameParserRuleCall_0_1 = (RuleCall)cVariableOrNodeVariableOrNodeCrossReference_0.eContents().get(1); |
718 | 741 | ||
719 | //Argument: | 742 | //VariableOrNodeArgument: |
720 | // variableOrNode=[VariableOrNode|QualifiedName]; | 743 | // variableOrNode=[VariableOrNode|QualifiedName]; |
721 | @Override public ParserRule getRule() { return rule; } | 744 | @Override public ParserRule getRule() { return rule; } |
722 | 745 | ||
@@ -729,6 +752,21 @@ public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarE | |||
729 | //QualifiedName | 752 | //QualifiedName |
730 | public RuleCall getVariableOrNodeVariableOrNodeQualifiedNameParserRuleCall_0_1() { return cVariableOrNodeVariableOrNodeQualifiedNameParserRuleCall_0_1; } | 753 | public RuleCall getVariableOrNodeVariableOrNodeQualifiedNameParserRuleCall_0_1() { return cVariableOrNodeVariableOrNodeQualifiedNameParserRuleCall_0_1; } |
731 | } | 754 | } |
755 | public class ConstantArgumentElements extends AbstractParserRuleElementFinder { | ||
756 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.ConstantArgument"); | ||
757 | private final Assignment cConstantAssignment = (Assignment)rule.eContents().get(1); | ||
758 | private final RuleCall cConstantConstantParserRuleCall_0 = (RuleCall)cConstantAssignment.eContents().get(0); | ||
759 | |||
760 | //ConstantArgument: | ||
761 | // constant=Constant; | ||
762 | @Override public ParserRule getRule() { return rule; } | ||
763 | |||
764 | //constant=Constant | ||
765 | public Assignment getConstantAssignment() { return cConstantAssignment; } | ||
766 | |||
767 | //Constant | ||
768 | public RuleCall getConstantConstantParserRuleCall_0() { return cConstantConstantParserRuleCall_0; } | ||
769 | } | ||
732 | public class AssertionElements extends AbstractParserRuleElementFinder { | 770 | public class AssertionElements extends AbstractParserRuleElementFinder { |
733 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.Assertion"); | 771 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.Assertion"); |
734 | private final Group cGroup = (Group)rule.eContents().get(1); | 772 | private final Group cGroup = (Group)rule.eContents().get(1); |
@@ -740,13 +778,11 @@ public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarE | |||
740 | private final Keyword cLeftParenthesisKeyword_0_0_1 = (Keyword)cGroup_0_0.eContents().get(1); | 778 | private final Keyword cLeftParenthesisKeyword_0_0_1 = (Keyword)cGroup_0_0.eContents().get(1); |
741 | private final Group cGroup_0_0_2 = (Group)cGroup_0_0.eContents().get(2); | 779 | private final Group cGroup_0_0_2 = (Group)cGroup_0_0.eContents().get(2); |
742 | private final Assignment cArgumentsAssignment_0_0_2_0 = (Assignment)cGroup_0_0_2.eContents().get(0); | 780 | private final Assignment cArgumentsAssignment_0_0_2_0 = (Assignment)cGroup_0_0_2.eContents().get(0); |
743 | private final CrossReference cArgumentsNodeCrossReference_0_0_2_0_0 = (CrossReference)cArgumentsAssignment_0_0_2_0.eContents().get(0); | 781 | private final RuleCall cArgumentsAssertionArgumentParserRuleCall_0_0_2_0_0 = (RuleCall)cArgumentsAssignment_0_0_2_0.eContents().get(0); |
744 | private final RuleCall cArgumentsNodeQualifiedNameParserRuleCall_0_0_2_0_0_1 = (RuleCall)cArgumentsNodeCrossReference_0_0_2_0_0.eContents().get(1); | ||
745 | private final Group cGroup_0_0_2_1 = (Group)cGroup_0_0_2.eContents().get(1); | 782 | private final Group cGroup_0_0_2_1 = (Group)cGroup_0_0_2.eContents().get(1); |
746 | private final Keyword cCommaKeyword_0_0_2_1_0 = (Keyword)cGroup_0_0_2_1.eContents().get(0); | 783 | private final Keyword cCommaKeyword_0_0_2_1_0 = (Keyword)cGroup_0_0_2_1.eContents().get(0); |
747 | private final Assignment cArgumentsAssignment_0_0_2_1_1 = (Assignment)cGroup_0_0_2_1.eContents().get(1); | 784 | private final Assignment cArgumentsAssignment_0_0_2_1_1 = (Assignment)cGroup_0_0_2_1.eContents().get(1); |
748 | private final CrossReference cArgumentsNodeCrossReference_0_0_2_1_1_0 = (CrossReference)cArgumentsAssignment_0_0_2_1_1.eContents().get(0); | 785 | private final RuleCall cArgumentsAssertionArgumentParserRuleCall_0_0_2_1_1_0 = (RuleCall)cArgumentsAssignment_0_0_2_1_1.eContents().get(0); |
749 | private final RuleCall cArgumentsNodeQualifiedNameParserRuleCall_0_0_2_1_1_0_1 = (RuleCall)cArgumentsNodeCrossReference_0_0_2_1_1_0.eContents().get(1); | ||
750 | private final Keyword cRightParenthesisKeyword_0_0_3 = (Keyword)cGroup_0_0.eContents().get(3); | 786 | private final Keyword cRightParenthesisKeyword_0_0_3 = (Keyword)cGroup_0_0.eContents().get(3); |
751 | private final Keyword cColonKeyword_0_0_4 = (Keyword)cGroup_0_0.eContents().get(4); | 787 | private final Keyword cColonKeyword_0_0_4 = (Keyword)cGroup_0_0.eContents().get(4); |
752 | private final Assignment cValueAssignment_0_0_5 = (Assignment)cGroup_0_0.eContents().get(5); | 788 | private final Assignment cValueAssignment_0_0_5 = (Assignment)cGroup_0_0.eContents().get(5); |
@@ -760,45 +796,43 @@ public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarE | |||
760 | private final Keyword cLeftParenthesisKeyword_0_1_2 = (Keyword)cGroup_0_1.eContents().get(2); | 796 | private final Keyword cLeftParenthesisKeyword_0_1_2 = (Keyword)cGroup_0_1.eContents().get(2); |
761 | private final Group cGroup_0_1_3 = (Group)cGroup_0_1.eContents().get(3); | 797 | private final Group cGroup_0_1_3 = (Group)cGroup_0_1.eContents().get(3); |
762 | private final Assignment cArgumentsAssignment_0_1_3_0 = (Assignment)cGroup_0_1_3.eContents().get(0); | 798 | private final Assignment cArgumentsAssignment_0_1_3_0 = (Assignment)cGroup_0_1_3.eContents().get(0); |
763 | private final CrossReference cArgumentsNodeCrossReference_0_1_3_0_0 = (CrossReference)cArgumentsAssignment_0_1_3_0.eContents().get(0); | 799 | private final RuleCall cArgumentsAssertionArgumentParserRuleCall_0_1_3_0_0 = (RuleCall)cArgumentsAssignment_0_1_3_0.eContents().get(0); |
764 | private final RuleCall cArgumentsNodeQualifiedNameParserRuleCall_0_1_3_0_0_1 = (RuleCall)cArgumentsNodeCrossReference_0_1_3_0_0.eContents().get(1); | ||
765 | private final Group cGroup_0_1_3_1 = (Group)cGroup_0_1_3.eContents().get(1); | 800 | private final Group cGroup_0_1_3_1 = (Group)cGroup_0_1_3.eContents().get(1); |
766 | private final Keyword cCommaKeyword_0_1_3_1_0 = (Keyword)cGroup_0_1_3_1.eContents().get(0); | 801 | private final Keyword cCommaKeyword_0_1_3_1_0 = (Keyword)cGroup_0_1_3_1.eContents().get(0); |
767 | private final Assignment cArgumentsAssignment_0_1_3_1_1 = (Assignment)cGroup_0_1_3_1.eContents().get(1); | 802 | private final Assignment cArgumentsAssignment_0_1_3_1_1 = (Assignment)cGroup_0_1_3_1.eContents().get(1); |
768 | private final CrossReference cArgumentsNodeCrossReference_0_1_3_1_1_0 = (CrossReference)cArgumentsAssignment_0_1_3_1_1.eContents().get(0); | 803 | private final RuleCall cArgumentsAssertionArgumentParserRuleCall_0_1_3_1_1_0 = (RuleCall)cArgumentsAssignment_0_1_3_1_1.eContents().get(0); |
769 | private final RuleCall cArgumentsNodeQualifiedNameParserRuleCall_0_1_3_1_1_0_1 = (RuleCall)cArgumentsNodeCrossReference_0_1_3_1_1_0.eContents().get(1); | ||
770 | private final Keyword cRightParenthesisKeyword_0_1_4 = (Keyword)cGroup_0_1.eContents().get(4); | 804 | private final Keyword cRightParenthesisKeyword_0_1_4 = (Keyword)cGroup_0_1.eContents().get(4); |
771 | private final Keyword cFullStopKeyword_1 = (Keyword)cGroup.eContents().get(1); | 805 | private final Keyword cFullStopKeyword_1 = (Keyword)cGroup.eContents().get(1); |
772 | 806 | ||
773 | //Assertion: | 807 | //Assertion: |
774 | // (relation=[Relation|QualifiedName] | 808 | // (relation=[Relation|QualifiedName] |
775 | // "(" (arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? ")" | 809 | // "(" (arguments+=AssertionArgument ("," arguments+=AssertionArgument)*)? ")" |
776 | // ":" value=LogicValue | | 810 | // ":" value=LogicValue | |
777 | // value=ShortLogicValue? | 811 | // value=ShortLogicValue? |
778 | // relation=[Relation|QualifiedName] | 812 | // relation=[Relation|QualifiedName] |
779 | // "(" (arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? ")") | 813 | // "(" (arguments+=AssertionArgument ("," arguments+=AssertionArgument)*)? ")") |
780 | // "."; | 814 | // "."; |
781 | @Override public ParserRule getRule() { return rule; } | 815 | @Override public ParserRule getRule() { return rule; } |
782 | 816 | ||
783 | //(relation=[Relation|QualifiedName] | 817 | //(relation=[Relation|QualifiedName] |
784 | //"(" (arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? ")" | 818 | //"(" (arguments+=AssertionArgument ("," arguments+=AssertionArgument)*)? ")" |
785 | //":" value=LogicValue | | 819 | //":" value=LogicValue | |
786 | //value=ShortLogicValue? | 820 | //value=ShortLogicValue? |
787 | //relation=[Relation|QualifiedName] | 821 | //relation=[Relation|QualifiedName] |
788 | //"(" (arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? ")") | 822 | //"(" (arguments+=AssertionArgument ("," arguments+=AssertionArgument)*)? ")") |
789 | //"." | 823 | //"." |
790 | public Group getGroup() { return cGroup; } | 824 | public Group getGroup() { return cGroup; } |
791 | 825 | ||
792 | //(relation=[Relation|QualifiedName] | 826 | //(relation=[Relation|QualifiedName] |
793 | //"(" (arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? ")" | 827 | //"(" (arguments+=AssertionArgument ("," arguments+=AssertionArgument)*)? ")" |
794 | //":" value=LogicValue | | 828 | //":" value=LogicValue | |
795 | //value=ShortLogicValue? | 829 | //value=ShortLogicValue? |
796 | //relation=[Relation|QualifiedName] | 830 | //relation=[Relation|QualifiedName] |
797 | //"(" (arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? ")") | 831 | //"(" (arguments+=AssertionArgument ("," arguments+=AssertionArgument)*)? ")") |
798 | public Alternatives getAlternatives_0() { return cAlternatives_0; } | 832 | public Alternatives getAlternatives_0() { return cAlternatives_0; } |
799 | 833 | ||
800 | //relation=[Relation|QualifiedName] | 834 | //relation=[Relation|QualifiedName] |
801 | // "(" (arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? ")" | 835 | // "(" (arguments+=AssertionArgument ("," arguments+=AssertionArgument)*)? ")" |
802 | // ":" value=LogicValue | 836 | // ":" value=LogicValue |
803 | public Group getGroup_0_0() { return cGroup_0_0; } | 837 | public Group getGroup_0_0() { return cGroup_0_0; } |
804 | 838 | ||
@@ -814,32 +848,26 @@ public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarE | |||
814 | //"(" | 848 | //"(" |
815 | public Keyword getLeftParenthesisKeyword_0_0_1() { return cLeftParenthesisKeyword_0_0_1; } | 849 | public Keyword getLeftParenthesisKeyword_0_0_1() { return cLeftParenthesisKeyword_0_0_1; } |
816 | 850 | ||
817 | //(arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? | 851 | //(arguments+=AssertionArgument ("," arguments+=AssertionArgument)*)? |
818 | public Group getGroup_0_0_2() { return cGroup_0_0_2; } | 852 | public Group getGroup_0_0_2() { return cGroup_0_0_2; } |
819 | 853 | ||
820 | //arguments+=[Node|QualifiedName] | 854 | //arguments+=AssertionArgument |
821 | public Assignment getArgumentsAssignment_0_0_2_0() { return cArgumentsAssignment_0_0_2_0; } | 855 | public Assignment getArgumentsAssignment_0_0_2_0() { return cArgumentsAssignment_0_0_2_0; } |
822 | 856 | ||
823 | //[Node|QualifiedName] | 857 | //AssertionArgument |
824 | public CrossReference getArgumentsNodeCrossReference_0_0_2_0_0() { return cArgumentsNodeCrossReference_0_0_2_0_0; } | 858 | public RuleCall getArgumentsAssertionArgumentParserRuleCall_0_0_2_0_0() { return cArgumentsAssertionArgumentParserRuleCall_0_0_2_0_0; } |
825 | |||
826 | //QualifiedName | ||
827 | public RuleCall getArgumentsNodeQualifiedNameParserRuleCall_0_0_2_0_0_1() { return cArgumentsNodeQualifiedNameParserRuleCall_0_0_2_0_0_1; } | ||
828 | 859 | ||
829 | //("," arguments+=[Node|QualifiedName])* | 860 | //("," arguments+=AssertionArgument)* |
830 | public Group getGroup_0_0_2_1() { return cGroup_0_0_2_1; } | 861 | public Group getGroup_0_0_2_1() { return cGroup_0_0_2_1; } |
831 | 862 | ||
832 | //"," | 863 | //"," |
833 | public Keyword getCommaKeyword_0_0_2_1_0() { return cCommaKeyword_0_0_2_1_0; } | 864 | public Keyword getCommaKeyword_0_0_2_1_0() { return cCommaKeyword_0_0_2_1_0; } |
834 | 865 | ||
835 | //arguments+=[Node|QualifiedName] | 866 | //arguments+=AssertionArgument |
836 | public Assignment getArgumentsAssignment_0_0_2_1_1() { return cArgumentsAssignment_0_0_2_1_1; } | 867 | public Assignment getArgumentsAssignment_0_0_2_1_1() { return cArgumentsAssignment_0_0_2_1_1; } |
837 | 868 | ||
838 | //[Node|QualifiedName] | 869 | //AssertionArgument |
839 | public CrossReference getArgumentsNodeCrossReference_0_0_2_1_1_0() { return cArgumentsNodeCrossReference_0_0_2_1_1_0; } | 870 | public RuleCall getArgumentsAssertionArgumentParserRuleCall_0_0_2_1_1_0() { return cArgumentsAssertionArgumentParserRuleCall_0_0_2_1_1_0; } |
840 | |||
841 | //QualifiedName | ||
842 | public RuleCall getArgumentsNodeQualifiedNameParserRuleCall_0_0_2_1_1_0_1() { return cArgumentsNodeQualifiedNameParserRuleCall_0_0_2_1_1_0_1; } | ||
843 | 871 | ||
844 | //")" | 872 | //")" |
845 | public Keyword getRightParenthesisKeyword_0_0_3() { return cRightParenthesisKeyword_0_0_3; } | 873 | public Keyword getRightParenthesisKeyword_0_0_3() { return cRightParenthesisKeyword_0_0_3; } |
@@ -855,7 +883,7 @@ public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarE | |||
855 | 883 | ||
856 | //value=ShortLogicValue? | 884 | //value=ShortLogicValue? |
857 | //relation=[Relation|QualifiedName] | 885 | //relation=[Relation|QualifiedName] |
858 | //"(" (arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? ")" | 886 | //"(" (arguments+=AssertionArgument ("," arguments+=AssertionArgument)*)? ")" |
859 | public Group getGroup_0_1() { return cGroup_0_1; } | 887 | public Group getGroup_0_1() { return cGroup_0_1; } |
860 | 888 | ||
861 | //value=ShortLogicValue? | 889 | //value=ShortLogicValue? |
@@ -876,32 +904,26 @@ public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarE | |||
876 | //"(" | 904 | //"(" |
877 | public Keyword getLeftParenthesisKeyword_0_1_2() { return cLeftParenthesisKeyword_0_1_2; } | 905 | public Keyword getLeftParenthesisKeyword_0_1_2() { return cLeftParenthesisKeyword_0_1_2; } |
878 | 906 | ||
879 | //(arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? | 907 | //(arguments+=AssertionArgument ("," arguments+=AssertionArgument)*)? |
880 | public Group getGroup_0_1_3() { return cGroup_0_1_3; } | 908 | public Group getGroup_0_1_3() { return cGroup_0_1_3; } |
881 | 909 | ||
882 | //arguments+=[Node|QualifiedName] | 910 | //arguments+=AssertionArgument |
883 | public Assignment getArgumentsAssignment_0_1_3_0() { return cArgumentsAssignment_0_1_3_0; } | 911 | public Assignment getArgumentsAssignment_0_1_3_0() { return cArgumentsAssignment_0_1_3_0; } |
884 | 912 | ||
885 | //[Node|QualifiedName] | 913 | //AssertionArgument |
886 | public CrossReference getArgumentsNodeCrossReference_0_1_3_0_0() { return cArgumentsNodeCrossReference_0_1_3_0_0; } | 914 | public RuleCall getArgumentsAssertionArgumentParserRuleCall_0_1_3_0_0() { return cArgumentsAssertionArgumentParserRuleCall_0_1_3_0_0; } |
887 | |||
888 | //QualifiedName | ||
889 | public RuleCall getArgumentsNodeQualifiedNameParserRuleCall_0_1_3_0_0_1() { return cArgumentsNodeQualifiedNameParserRuleCall_0_1_3_0_0_1; } | ||
890 | 915 | ||
891 | //("," arguments+=[Node|QualifiedName])* | 916 | //("," arguments+=AssertionArgument)* |
892 | public Group getGroup_0_1_3_1() { return cGroup_0_1_3_1; } | 917 | public Group getGroup_0_1_3_1() { return cGroup_0_1_3_1; } |
893 | 918 | ||
894 | //"," | 919 | //"," |
895 | public Keyword getCommaKeyword_0_1_3_1_0() { return cCommaKeyword_0_1_3_1_0; } | 920 | public Keyword getCommaKeyword_0_1_3_1_0() { return cCommaKeyword_0_1_3_1_0; } |
896 | 921 | ||
897 | //arguments+=[Node|QualifiedName] | 922 | //arguments+=AssertionArgument |
898 | public Assignment getArgumentsAssignment_0_1_3_1_1() { return cArgumentsAssignment_0_1_3_1_1; } | 923 | public Assignment getArgumentsAssignment_0_1_3_1_1() { return cArgumentsAssignment_0_1_3_1_1; } |
899 | 924 | ||
900 | //[Node|QualifiedName] | 925 | //AssertionArgument |
901 | public CrossReference getArgumentsNodeCrossReference_0_1_3_1_1_0() { return cArgumentsNodeCrossReference_0_1_3_1_1_0; } | 926 | public RuleCall getArgumentsAssertionArgumentParserRuleCall_0_1_3_1_1_0() { return cArgumentsAssertionArgumentParserRuleCall_0_1_3_1_1_0; } |
902 | |||
903 | //QualifiedName | ||
904 | public RuleCall getArgumentsNodeQualifiedNameParserRuleCall_0_1_3_1_1_0_1() { return cArgumentsNodeQualifiedNameParserRuleCall_0_1_3_1_1_0_1; } | ||
905 | 927 | ||
906 | //")" | 928 | //")" |
907 | public Keyword getRightParenthesisKeyword_0_1_4() { return cRightParenthesisKeyword_0_1_4; } | 929 | public Keyword getRightParenthesisKeyword_0_1_4() { return cRightParenthesisKeyword_0_1_4; } |
@@ -909,6 +931,166 @@ public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarE | |||
909 | //"." | 931 | //"." |
910 | public Keyword getFullStopKeyword_1() { return cFullStopKeyword_1; } | 932 | public Keyword getFullStopKeyword_1() { return cFullStopKeyword_1; } |
911 | } | 933 | } |
934 | public class AssertionArgumentElements extends AbstractParserRuleElementFinder { | ||
935 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.AssertionArgument"); | ||
936 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
937 | private final RuleCall cNodeAssertionArgumentParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | ||
938 | private final RuleCall cConstantAssertionArgumentParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | ||
939 | |||
940 | //AssertionArgument: | ||
941 | // NodeAssertionArgument | ConstantAssertionArgument; | ||
942 | @Override public ParserRule getRule() { return rule; } | ||
943 | |||
944 | //NodeAssertionArgument | ConstantAssertionArgument | ||
945 | public Alternatives getAlternatives() { return cAlternatives; } | ||
946 | |||
947 | //NodeAssertionArgument | ||
948 | public RuleCall getNodeAssertionArgumentParserRuleCall_0() { return cNodeAssertionArgumentParserRuleCall_0; } | ||
949 | |||
950 | //ConstantAssertionArgument | ||
951 | public RuleCall getConstantAssertionArgumentParserRuleCall_1() { return cConstantAssertionArgumentParserRuleCall_1; } | ||
952 | } | ||
953 | public class NodeAssertionArgumentElements extends AbstractParserRuleElementFinder { | ||
954 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.NodeAssertionArgument"); | ||
955 | private final Assignment cNodeAssignment = (Assignment)rule.eContents().get(1); | ||
956 | private final CrossReference cNodeNodeCrossReference_0 = (CrossReference)cNodeAssignment.eContents().get(0); | ||
957 | private final RuleCall cNodeNodeQualifiedNameParserRuleCall_0_1 = (RuleCall)cNodeNodeCrossReference_0.eContents().get(1); | ||
958 | |||
959 | //NodeAssertionArgument: | ||
960 | // node=[Node|QualifiedName]; | ||
961 | @Override public ParserRule getRule() { return rule; } | ||
962 | |||
963 | //node=[Node|QualifiedName] | ||
964 | public Assignment getNodeAssignment() { return cNodeAssignment; } | ||
965 | |||
966 | //[Node|QualifiedName] | ||
967 | public CrossReference getNodeNodeCrossReference_0() { return cNodeNodeCrossReference_0; } | ||
968 | |||
969 | //QualifiedName | ||
970 | public RuleCall getNodeNodeQualifiedNameParserRuleCall_0_1() { return cNodeNodeQualifiedNameParserRuleCall_0_1; } | ||
971 | } | ||
972 | public class ConstantAssertionArgumentElements extends AbstractParserRuleElementFinder { | ||
973 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.ConstantAssertionArgument"); | ||
974 | private final Assignment cConstantAssignment = (Assignment)rule.eContents().get(1); | ||
975 | private final RuleCall cConstantConstantParserRuleCall_0 = (RuleCall)cConstantAssignment.eContents().get(0); | ||
976 | |||
977 | //ConstantAssertionArgument: | ||
978 | // constant=Constant; | ||
979 | @Override public ParserRule getRule() { return rule; } | ||
980 | |||
981 | //constant=Constant | ||
982 | public Assignment getConstantAssignment() { return cConstantAssignment; } | ||
983 | |||
984 | //Constant | ||
985 | public RuleCall getConstantConstantParserRuleCall_0() { return cConstantConstantParserRuleCall_0; } | ||
986 | } | ||
987 | public class NodeValueAssertionElements extends AbstractParserRuleElementFinder { | ||
988 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.NodeValueAssertion"); | ||
989 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
990 | private final Assignment cNodeAssignment_0 = (Assignment)cGroup.eContents().get(0); | ||
991 | private final CrossReference cNodeNodeCrossReference_0_0 = (CrossReference)cNodeAssignment_0.eContents().get(0); | ||
992 | private final RuleCall cNodeNodeQualifiedNameParserRuleCall_0_0_1 = (RuleCall)cNodeNodeCrossReference_0_0.eContents().get(1); | ||
993 | private final Keyword cColonKeyword_1 = (Keyword)cGroup.eContents().get(1); | ||
994 | private final Assignment cValueAssignment_2 = (Assignment)cGroup.eContents().get(2); | ||
995 | private final RuleCall cValueConstantParserRuleCall_2_0 = (RuleCall)cValueAssignment_2.eContents().get(0); | ||
996 | private final Keyword cFullStopKeyword_3 = (Keyword)cGroup.eContents().get(3); | ||
997 | |||
998 | //NodeValueAssertion: | ||
999 | // node=[Node|QualifiedName] ":" value=Constant "."; | ||
1000 | @Override public ParserRule getRule() { return rule; } | ||
1001 | |||
1002 | //node=[Node|QualifiedName] ":" value=Constant "." | ||
1003 | public Group getGroup() { return cGroup; } | ||
1004 | |||
1005 | //node=[Node|QualifiedName] | ||
1006 | public Assignment getNodeAssignment_0() { return cNodeAssignment_0; } | ||
1007 | |||
1008 | //[Node|QualifiedName] | ||
1009 | public CrossReference getNodeNodeCrossReference_0_0() { return cNodeNodeCrossReference_0_0; } | ||
1010 | |||
1011 | //QualifiedName | ||
1012 | public RuleCall getNodeNodeQualifiedNameParserRuleCall_0_0_1() { return cNodeNodeQualifiedNameParserRuleCall_0_0_1; } | ||
1013 | |||
1014 | //":" | ||
1015 | public Keyword getColonKeyword_1() { return cColonKeyword_1; } | ||
1016 | |||
1017 | //value=Constant | ||
1018 | public Assignment getValueAssignment_2() { return cValueAssignment_2; } | ||
1019 | |||
1020 | //Constant | ||
1021 | public RuleCall getValueConstantParserRuleCall_2_0() { return cValueConstantParserRuleCall_2_0; } | ||
1022 | |||
1023 | //"." | ||
1024 | public Keyword getFullStopKeyword_3() { return cFullStopKeyword_3; } | ||
1025 | } | ||
1026 | public class ConstantElements extends AbstractParserRuleElementFinder { | ||
1027 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.Constant"); | ||
1028 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
1029 | private final RuleCall cIntConstantParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | ||
1030 | private final RuleCall cRealConstantParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | ||
1031 | private final RuleCall cStringConstantParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); | ||
1032 | |||
1033 | //Constant: | ||
1034 | // IntConstant | RealConstant | StringConstant; | ||
1035 | @Override public ParserRule getRule() { return rule; } | ||
1036 | |||
1037 | //IntConstant | RealConstant | StringConstant | ||
1038 | public Alternatives getAlternatives() { return cAlternatives; } | ||
1039 | |||
1040 | //IntConstant | ||
1041 | public RuleCall getIntConstantParserRuleCall_0() { return cIntConstantParserRuleCall_0; } | ||
1042 | |||
1043 | //RealConstant | ||
1044 | public RuleCall getRealConstantParserRuleCall_1() { return cRealConstantParserRuleCall_1; } | ||
1045 | |||
1046 | //StringConstant | ||
1047 | public RuleCall getStringConstantParserRuleCall_2() { return cStringConstantParserRuleCall_2; } | ||
1048 | } | ||
1049 | public class IntConstantElements extends AbstractParserRuleElementFinder { | ||
1050 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.IntConstant"); | ||
1051 | private final Assignment cIntValueAssignment = (Assignment)rule.eContents().get(1); | ||
1052 | private final RuleCall cIntValueIntegerParserRuleCall_0 = (RuleCall)cIntValueAssignment.eContents().get(0); | ||
1053 | |||
1054 | //IntConstant: | ||
1055 | // intValue=Integer; | ||
1056 | @Override public ParserRule getRule() { return rule; } | ||
1057 | |||
1058 | //intValue=Integer | ||
1059 | public Assignment getIntValueAssignment() { return cIntValueAssignment; } | ||
1060 | |||
1061 | //Integer | ||
1062 | public RuleCall getIntValueIntegerParserRuleCall_0() { return cIntValueIntegerParserRuleCall_0; } | ||
1063 | } | ||
1064 | public class RealConstantElements extends AbstractParserRuleElementFinder { | ||
1065 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.RealConstant"); | ||
1066 | private final Assignment cRealValueAssignment = (Assignment)rule.eContents().get(1); | ||
1067 | private final RuleCall cRealValueRealParserRuleCall_0 = (RuleCall)cRealValueAssignment.eContents().get(0); | ||
1068 | |||
1069 | //RealConstant: | ||
1070 | // realValue=Real; | ||
1071 | @Override public ParserRule getRule() { return rule; } | ||
1072 | |||
1073 | //realValue=Real | ||
1074 | public Assignment getRealValueAssignment() { return cRealValueAssignment; } | ||
1075 | |||
1076 | //Real | ||
1077 | public RuleCall getRealValueRealParserRuleCall_0() { return cRealValueRealParserRuleCall_0; } | ||
1078 | } | ||
1079 | public class StringConstantElements extends AbstractParserRuleElementFinder { | ||
1080 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.StringConstant"); | ||
1081 | private final Assignment cStringValueAssignment = (Assignment)rule.eContents().get(1); | ||
1082 | private final RuleCall cStringValueSTRINGTerminalRuleCall_0 = (RuleCall)cStringValueAssignment.eContents().get(0); | ||
1083 | |||
1084 | //StringConstant: | ||
1085 | // stringValue=STRING; | ||
1086 | @Override public ParserRule getRule() { return rule; } | ||
1087 | |||
1088 | //stringValue=STRING | ||
1089 | public Assignment getStringValueAssignment() { return cStringValueAssignment; } | ||
1090 | |||
1091 | //STRING | ||
1092 | public RuleCall getStringValueSTRINGTerminalRuleCall_0() { return cStringValueSTRINGTerminalRuleCall_0; } | ||
1093 | } | ||
912 | public class ScopeDeclarationElements extends AbstractParserRuleElementFinder { | 1094 | public class ScopeDeclarationElements extends AbstractParserRuleElementFinder { |
913 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.ScopeDeclaration"); | 1095 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.ScopeDeclaration"); |
914 | private final Group cGroup = (Group)rule.eContents().get(1); | 1096 | private final Group cGroup = (Group)rule.eContents().get(1); |
@@ -1149,7 +1331,7 @@ public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarE | |||
1149 | private final Keyword cColonColonKeyword_1_2_0 = (Keyword)cGroup_1_2.eContents().get(0); | 1331 | private final Keyword cColonColonKeyword_1_2_0 = (Keyword)cGroup_1_2.eContents().get(0); |
1150 | private final RuleCall cQUOTED_IDTerminalRuleCall_1_2_1 = (RuleCall)cGroup_1_2.eContents().get(1); | 1332 | private final RuleCall cQUOTED_IDTerminalRuleCall_1_2_1 = (RuleCall)cGroup_1_2.eContents().get(1); |
1151 | 1333 | ||
1152 | //QualifiedName: | 1334 | //QualifiedName hidden(): |
1153 | // QUOTED_ID | Identifier ("::" Identifier)* ("::" QUOTED_ID)?; | 1335 | // QUOTED_ID | Identifier ("::" Identifier)* ("::" QUOTED_ID)?; |
1154 | @Override public ParserRule getRule() { return rule; } | 1336 | @Override public ParserRule getRule() { return rule; } |
1155 | 1337 | ||
@@ -1189,12 +1371,14 @@ public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarE | |||
1189 | private final RuleCall cIDTerminalRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | 1371 | private final RuleCall cIDTerminalRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); |
1190 | private final Keyword cTrueKeyword_1 = (Keyword)cAlternatives.eContents().get(1); | 1372 | private final Keyword cTrueKeyword_1 = (Keyword)cAlternatives.eContents().get(1); |
1191 | private final Keyword cFalseKeyword_2 = (Keyword)cAlternatives.eContents().get(2); | 1373 | private final Keyword cFalseKeyword_2 = (Keyword)cAlternatives.eContents().get(2); |
1374 | private final Keyword cEKeyword_3 = (Keyword)cAlternatives.eContents().get(3); | ||
1375 | private final Keyword cEKeyword_4 = (Keyword)cAlternatives.eContents().get(4); | ||
1192 | 1376 | ||
1193 | //Identifier: | 1377 | //Identifier: |
1194 | // ID | "true" | "false"; | 1378 | // ID | "true" | "false" | "e" | "E"; |
1195 | @Override public ParserRule getRule() { return rule; } | 1379 | @Override public ParserRule getRule() { return rule; } |
1196 | 1380 | ||
1197 | //ID | "true" | "false" | 1381 | //ID | "true" | "false" | "e" | "E" |
1198 | public Alternatives getAlternatives() { return cAlternatives; } | 1382 | public Alternatives getAlternatives() { return cAlternatives; } |
1199 | 1383 | ||
1200 | //ID | 1384 | //ID |
@@ -1205,6 +1389,110 @@ public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarE | |||
1205 | 1389 | ||
1206 | //"false" | 1390 | //"false" |
1207 | public Keyword getFalseKeyword_2() { return cFalseKeyword_2; } | 1391 | public Keyword getFalseKeyword_2() { return cFalseKeyword_2; } |
1392 | |||
1393 | //"e" | ||
1394 | public Keyword getEKeyword_3() { return cEKeyword_3; } | ||
1395 | |||
1396 | //"E" | ||
1397 | public Keyword getEKeyword_4() { return cEKeyword_4; } | ||
1398 | } | ||
1399 | public class IntegerElements extends AbstractParserRuleElementFinder { | ||
1400 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.Integer"); | ||
1401 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
1402 | private final Keyword cHyphenMinusKeyword_0 = (Keyword)cGroup.eContents().get(0); | ||
1403 | private final RuleCall cINTTerminalRuleCall_1 = (RuleCall)cGroup.eContents().get(1); | ||
1404 | |||
1405 | //Integer returns ecore::EInt hidden(): | ||
1406 | // "-"? INT; | ||
1407 | @Override public ParserRule getRule() { return rule; } | ||
1408 | |||
1409 | //"-"? INT | ||
1410 | public Group getGroup() { return cGroup; } | ||
1411 | |||
1412 | //"-"? | ||
1413 | public Keyword getHyphenMinusKeyword_0() { return cHyphenMinusKeyword_0; } | ||
1414 | |||
1415 | //INT | ||
1416 | public RuleCall getINTTerminalRuleCall_1() { return cINTTerminalRuleCall_1; } | ||
1417 | } | ||
1418 | public class RealElements extends AbstractParserRuleElementFinder { | ||
1419 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.Real"); | ||
1420 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
1421 | private final Keyword cHyphenMinusKeyword_0 = (Keyword)cGroup.eContents().get(0); | ||
1422 | private final RuleCall cINTTerminalRuleCall_1 = (RuleCall)cGroup.eContents().get(1); | ||
1423 | private final Alternatives cAlternatives_2 = (Alternatives)cGroup.eContents().get(2); | ||
1424 | private final Group cGroup_2_0 = (Group)cAlternatives_2.eContents().get(0); | ||
1425 | private final Keyword cFullStopKeyword_2_0_0 = (Keyword)cGroup_2_0.eContents().get(0); | ||
1426 | private final RuleCall cINTTerminalRuleCall_2_0_1 = (RuleCall)cGroup_2_0.eContents().get(1); | ||
1427 | private final Group cGroup_2_1 = (Group)cAlternatives_2.eContents().get(1); | ||
1428 | private final Group cGroup_2_1_0 = (Group)cGroup_2_1.eContents().get(0); | ||
1429 | private final Keyword cFullStopKeyword_2_1_0_0 = (Keyword)cGroup_2_1_0.eContents().get(0); | ||
1430 | private final RuleCall cINTTerminalRuleCall_2_1_0_1 = (RuleCall)cGroup_2_1_0.eContents().get(1); | ||
1431 | private final Alternatives cAlternatives_2_1_1 = (Alternatives)cGroup_2_1.eContents().get(1); | ||
1432 | private final Keyword cEKeyword_2_1_1_0 = (Keyword)cAlternatives_2_1_1.eContents().get(0); | ||
1433 | private final Keyword cEKeyword_2_1_1_1 = (Keyword)cAlternatives_2_1_1.eContents().get(1); | ||
1434 | private final Alternatives cAlternatives_2_1_2 = (Alternatives)cGroup_2_1.eContents().get(2); | ||
1435 | private final Keyword cHyphenMinusKeyword_2_1_2_0 = (Keyword)cAlternatives_2_1_2.eContents().get(0); | ||
1436 | private final Keyword cPlusSignKeyword_2_1_2_1 = (Keyword)cAlternatives_2_1_2.eContents().get(1); | ||
1437 | private final RuleCall cINTTerminalRuleCall_2_1_3 = (RuleCall)cGroup_2_1.eContents().get(3); | ||
1438 | |||
1439 | //Real returns ecore::EDouble hidden(): | ||
1440 | // "-"? INT ("." INT | ("." INT)? ("e" | "E") ("-" | "+")? INT); | ||
1441 | @Override public ParserRule getRule() { return rule; } | ||
1442 | |||
1443 | //"-"? INT ("." INT | ("." INT)? ("e" | "E") ("-" | "+")? INT) | ||
1444 | public Group getGroup() { return cGroup; } | ||
1445 | |||
1446 | //"-"? | ||
1447 | public Keyword getHyphenMinusKeyword_0() { return cHyphenMinusKeyword_0; } | ||
1448 | |||
1449 | //INT | ||
1450 | public RuleCall getINTTerminalRuleCall_1() { return cINTTerminalRuleCall_1; } | ||
1451 | |||
1452 | //("." INT | ("." INT)? ("e" | "E") ("-" | "+")? INT) | ||
1453 | public Alternatives getAlternatives_2() { return cAlternatives_2; } | ||
1454 | |||
1455 | //"." INT | ||
1456 | public Group getGroup_2_0() { return cGroup_2_0; } | ||
1457 | |||
1458 | //"." | ||
1459 | public Keyword getFullStopKeyword_2_0_0() { return cFullStopKeyword_2_0_0; } | ||
1460 | |||
1461 | //INT | ||
1462 | public RuleCall getINTTerminalRuleCall_2_0_1() { return cINTTerminalRuleCall_2_0_1; } | ||
1463 | |||
1464 | //("." INT)? ("e" | "E") ("-" | "+")? INT | ||
1465 | public Group getGroup_2_1() { return cGroup_2_1; } | ||
1466 | |||
1467 | //("." INT)? | ||
1468 | public Group getGroup_2_1_0() { return cGroup_2_1_0; } | ||
1469 | |||
1470 | //"." | ||
1471 | public Keyword getFullStopKeyword_2_1_0_0() { return cFullStopKeyword_2_1_0_0; } | ||
1472 | |||
1473 | //INT | ||
1474 | public RuleCall getINTTerminalRuleCall_2_1_0_1() { return cINTTerminalRuleCall_2_1_0_1; } | ||
1475 | |||
1476 | //("e" | "E") | ||
1477 | public Alternatives getAlternatives_2_1_1() { return cAlternatives_2_1_1; } | ||
1478 | |||
1479 | //"e" | ||
1480 | public Keyword getEKeyword_2_1_1_0() { return cEKeyword_2_1_1_0; } | ||
1481 | |||
1482 | //"E" | ||
1483 | public Keyword getEKeyword_2_1_1_1() { return cEKeyword_2_1_1_1; } | ||
1484 | |||
1485 | //("-" | "+")? | ||
1486 | public Alternatives getAlternatives_2_1_2() { return cAlternatives_2_1_2; } | ||
1487 | |||
1488 | //"-" | ||
1489 | public Keyword getHyphenMinusKeyword_2_1_2_0() { return cHyphenMinusKeyword_2_1_2_0; } | ||
1490 | |||
1491 | //"+" | ||
1492 | public Keyword getPlusSignKeyword_2_1_2_1() { return cPlusSignKeyword_2_1_2_1; } | ||
1493 | |||
1494 | //INT | ||
1495 | public RuleCall getINTTerminalRuleCall_2_1_3() { return cINTTerminalRuleCall_2_1_3; } | ||
1208 | } | 1496 | } |
1209 | 1497 | ||
1210 | public class LogicValueElements extends AbstractElementFinder.AbstractEnumRuleElementFinder { | 1498 | public class LogicValueElements extends AbstractElementFinder.AbstractEnumRuleElementFinder { |
@@ -1283,9 +1571,19 @@ public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarE | |||
1283 | private final NegativeLiteralElements pNegativeLiteral; | 1571 | private final NegativeLiteralElements pNegativeLiteral; |
1284 | private final AtomElements pAtom; | 1572 | private final AtomElements pAtom; |
1285 | private final ArgumentElements pArgument; | 1573 | private final ArgumentElements pArgument; |
1574 | private final VariableOrNodeArgumentElements pVariableOrNodeArgument; | ||
1575 | private final ConstantArgumentElements pConstantArgument; | ||
1286 | private final AssertionElements pAssertion; | 1576 | private final AssertionElements pAssertion; |
1577 | private final AssertionArgumentElements pAssertionArgument; | ||
1578 | private final NodeAssertionArgumentElements pNodeAssertionArgument; | ||
1579 | private final ConstantAssertionArgumentElements pConstantAssertionArgument; | ||
1287 | private final LogicValueElements eLogicValue; | 1580 | private final LogicValueElements eLogicValue; |
1288 | private final ShortLogicValueElements eShortLogicValue; | 1581 | private final ShortLogicValueElements eShortLogicValue; |
1582 | private final NodeValueAssertionElements pNodeValueAssertion; | ||
1583 | private final ConstantElements pConstant; | ||
1584 | private final IntConstantElements pIntConstant; | ||
1585 | private final RealConstantElements pRealConstant; | ||
1586 | private final StringConstantElements pStringConstant; | ||
1289 | private final ScopeDeclarationElements pScopeDeclaration; | 1587 | private final ScopeDeclarationElements pScopeDeclaration; |
1290 | private final TypeScopeElements pTypeScope; | 1588 | private final TypeScopeElements pTypeScope; |
1291 | private final MultiplicityElements pMultiplicity; | 1589 | private final MultiplicityElements pMultiplicity; |
@@ -1297,6 +1595,9 @@ public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarE | |||
1297 | private final QuotedOrUnquotedIdElements pQuotedOrUnquotedId; | 1595 | private final QuotedOrUnquotedIdElements pQuotedOrUnquotedId; |
1298 | private final QualifiedNameElements pQualifiedName; | 1596 | private final QualifiedNameElements pQualifiedName; |
1299 | private final IdentifierElements pIdentifier; | 1597 | private final IdentifierElements pIdentifier; |
1598 | private final IntegerElements pInteger; | ||
1599 | private final RealElements pReal; | ||
1600 | private final TerminalRule tID; | ||
1300 | private final TerminalRule tSTRING; | 1601 | private final TerminalRule tSTRING; |
1301 | private final TerminalRule tQUOTED_ID; | 1602 | private final TerminalRule tQUOTED_ID; |
1302 | private final TerminalRule tSL_COMMENT; | 1603 | private final TerminalRule tSL_COMMENT; |
@@ -1323,9 +1624,19 @@ public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarE | |||
1323 | this.pNegativeLiteral = new NegativeLiteralElements(); | 1624 | this.pNegativeLiteral = new NegativeLiteralElements(); |
1324 | this.pAtom = new AtomElements(); | 1625 | this.pAtom = new AtomElements(); |
1325 | this.pArgument = new ArgumentElements(); | 1626 | this.pArgument = new ArgumentElements(); |
1627 | this.pVariableOrNodeArgument = new VariableOrNodeArgumentElements(); | ||
1628 | this.pConstantArgument = new ConstantArgumentElements(); | ||
1326 | this.pAssertion = new AssertionElements(); | 1629 | this.pAssertion = new AssertionElements(); |
1630 | this.pAssertionArgument = new AssertionArgumentElements(); | ||
1631 | this.pNodeAssertionArgument = new NodeAssertionArgumentElements(); | ||
1632 | this.pConstantAssertionArgument = new ConstantAssertionArgumentElements(); | ||
1327 | this.eLogicValue = new LogicValueElements(); | 1633 | this.eLogicValue = new LogicValueElements(); |
1328 | this.eShortLogicValue = new ShortLogicValueElements(); | 1634 | this.eShortLogicValue = new ShortLogicValueElements(); |
1635 | this.pNodeValueAssertion = new NodeValueAssertionElements(); | ||
1636 | this.pConstant = new ConstantElements(); | ||
1637 | this.pIntConstant = new IntConstantElements(); | ||
1638 | this.pRealConstant = new RealConstantElements(); | ||
1639 | this.pStringConstant = new StringConstantElements(); | ||
1329 | this.pScopeDeclaration = new ScopeDeclarationElements(); | 1640 | this.pScopeDeclaration = new ScopeDeclarationElements(); |
1330 | this.pTypeScope = new TypeScopeElements(); | 1641 | this.pTypeScope = new TypeScopeElements(); |
1331 | this.pMultiplicity = new MultiplicityElements(); | 1642 | this.pMultiplicity = new MultiplicityElements(); |
@@ -1337,6 +1648,9 @@ public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarE | |||
1337 | this.pQuotedOrUnquotedId = new QuotedOrUnquotedIdElements(); | 1648 | this.pQuotedOrUnquotedId = new QuotedOrUnquotedIdElements(); |
1338 | this.pQualifiedName = new QualifiedNameElements(); | 1649 | this.pQualifiedName = new QualifiedNameElements(); |
1339 | this.pIdentifier = new IdentifierElements(); | 1650 | this.pIdentifier = new IdentifierElements(); |
1651 | this.pInteger = new IntegerElements(); | ||
1652 | this.pReal = new RealElements(); | ||
1653 | this.tID = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.ID"); | ||
1340 | this.tSTRING = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.STRING"); | 1654 | this.tSTRING = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.STRING"); |
1341 | this.tQUOTED_ID = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.QUOTED_ID"); | 1655 | this.tQUOTED_ID = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.QUOTED_ID"); |
1342 | this.tSL_COMMENT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.SL_COMMENT"); | 1656 | this.tSL_COMMENT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.SL_COMMENT"); |
@@ -1381,7 +1695,7 @@ public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarE | |||
1381 | } | 1695 | } |
1382 | 1696 | ||
1383 | //Statement: | 1697 | //Statement: |
1384 | // ClassDeclaration | EnumDeclaration | PredicateDefinition | Assertion | ScopeDeclaration; | 1698 | // ClassDeclaration | EnumDeclaration | PredicateDefinition | Assertion | NodeValueAssertion | ScopeDeclaration; |
1385 | public StatementElements getStatementAccess() { | 1699 | public StatementElements getStatementAccess() { |
1386 | return pStatement; | 1700 | return pStatement; |
1387 | } | 1701 | } |
@@ -1506,7 +1820,7 @@ public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarE | |||
1506 | } | 1820 | } |
1507 | 1821 | ||
1508 | //Argument: | 1822 | //Argument: |
1509 | // variableOrNode=[VariableOrNode|QualifiedName]; | 1823 | // VariableOrNodeArgument | ConstantArgument; |
1510 | public ArgumentElements getArgumentAccess() { | 1824 | public ArgumentElements getArgumentAccess() { |
1511 | return pArgument; | 1825 | return pArgument; |
1512 | } | 1826 | } |
@@ -1515,13 +1829,33 @@ public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarE | |||
1515 | return getArgumentAccess().getRule(); | 1829 | return getArgumentAccess().getRule(); |
1516 | } | 1830 | } |
1517 | 1831 | ||
1832 | //VariableOrNodeArgument: | ||
1833 | // variableOrNode=[VariableOrNode|QualifiedName]; | ||
1834 | public VariableOrNodeArgumentElements getVariableOrNodeArgumentAccess() { | ||
1835 | return pVariableOrNodeArgument; | ||
1836 | } | ||
1837 | |||
1838 | public ParserRule getVariableOrNodeArgumentRule() { | ||
1839 | return getVariableOrNodeArgumentAccess().getRule(); | ||
1840 | } | ||
1841 | |||
1842 | //ConstantArgument: | ||
1843 | // constant=Constant; | ||
1844 | public ConstantArgumentElements getConstantArgumentAccess() { | ||
1845 | return pConstantArgument; | ||
1846 | } | ||
1847 | |||
1848 | public ParserRule getConstantArgumentRule() { | ||
1849 | return getConstantArgumentAccess().getRule(); | ||
1850 | } | ||
1851 | |||
1518 | //Assertion: | 1852 | //Assertion: |
1519 | // (relation=[Relation|QualifiedName] | 1853 | // (relation=[Relation|QualifiedName] |
1520 | // "(" (arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? ")" | 1854 | // "(" (arguments+=AssertionArgument ("," arguments+=AssertionArgument)*)? ")" |
1521 | // ":" value=LogicValue | | 1855 | // ":" value=LogicValue | |
1522 | // value=ShortLogicValue? | 1856 | // value=ShortLogicValue? |
1523 | // relation=[Relation|QualifiedName] | 1857 | // relation=[Relation|QualifiedName] |
1524 | // "(" (arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? ")") | 1858 | // "(" (arguments+=AssertionArgument ("," arguments+=AssertionArgument)*)? ")") |
1525 | // "."; | 1859 | // "."; |
1526 | public AssertionElements getAssertionAccess() { | 1860 | public AssertionElements getAssertionAccess() { |
1527 | return pAssertion; | 1861 | return pAssertion; |
@@ -1531,6 +1865,36 @@ public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarE | |||
1531 | return getAssertionAccess().getRule(); | 1865 | return getAssertionAccess().getRule(); |
1532 | } | 1866 | } |
1533 | 1867 | ||
1868 | //AssertionArgument: | ||
1869 | // NodeAssertionArgument | ConstantAssertionArgument; | ||
1870 | public AssertionArgumentElements getAssertionArgumentAccess() { | ||
1871 | return pAssertionArgument; | ||
1872 | } | ||
1873 | |||
1874 | public ParserRule getAssertionArgumentRule() { | ||
1875 | return getAssertionArgumentAccess().getRule(); | ||
1876 | } | ||
1877 | |||
1878 | //NodeAssertionArgument: | ||
1879 | // node=[Node|QualifiedName]; | ||
1880 | public NodeAssertionArgumentElements getNodeAssertionArgumentAccess() { | ||
1881 | return pNodeAssertionArgument; | ||
1882 | } | ||
1883 | |||
1884 | public ParserRule getNodeAssertionArgumentRule() { | ||
1885 | return getNodeAssertionArgumentAccess().getRule(); | ||
1886 | } | ||
1887 | |||
1888 | //ConstantAssertionArgument: | ||
1889 | // constant=Constant; | ||
1890 | public ConstantAssertionArgumentElements getConstantAssertionArgumentAccess() { | ||
1891 | return pConstantAssertionArgument; | ||
1892 | } | ||
1893 | |||
1894 | public ParserRule getConstantAssertionArgumentRule() { | ||
1895 | return getConstantAssertionArgumentAccess().getRule(); | ||
1896 | } | ||
1897 | |||
1534 | //enum LogicValue: | 1898 | //enum LogicValue: |
1535 | // TRUE="true" | FALSE="false" | UNKNOWN="unknown"; | 1899 | // TRUE="true" | FALSE="false" | UNKNOWN="unknown"; |
1536 | public LogicValueElements getLogicValueAccess() { | 1900 | public LogicValueElements getLogicValueAccess() { |
@@ -1551,6 +1915,56 @@ public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarE | |||
1551 | return getShortLogicValueAccess().getRule(); | 1915 | return getShortLogicValueAccess().getRule(); |
1552 | } | 1916 | } |
1553 | 1917 | ||
1918 | //NodeValueAssertion: | ||
1919 | // node=[Node|QualifiedName] ":" value=Constant "."; | ||
1920 | public NodeValueAssertionElements getNodeValueAssertionAccess() { | ||
1921 | return pNodeValueAssertion; | ||
1922 | } | ||
1923 | |||
1924 | public ParserRule getNodeValueAssertionRule() { | ||
1925 | return getNodeValueAssertionAccess().getRule(); | ||
1926 | } | ||
1927 | |||
1928 | //Constant: | ||
1929 | // IntConstant | RealConstant | StringConstant; | ||
1930 | public ConstantElements getConstantAccess() { | ||
1931 | return pConstant; | ||
1932 | } | ||
1933 | |||
1934 | public ParserRule getConstantRule() { | ||
1935 | return getConstantAccess().getRule(); | ||
1936 | } | ||
1937 | |||
1938 | //IntConstant: | ||
1939 | // intValue=Integer; | ||
1940 | public IntConstantElements getIntConstantAccess() { | ||
1941 | return pIntConstant; | ||
1942 | } | ||
1943 | |||
1944 | public ParserRule getIntConstantRule() { | ||
1945 | return getIntConstantAccess().getRule(); | ||
1946 | } | ||
1947 | |||
1948 | //RealConstant: | ||
1949 | // realValue=Real; | ||
1950 | public RealConstantElements getRealConstantAccess() { | ||
1951 | return pRealConstant; | ||
1952 | } | ||
1953 | |||
1954 | public ParserRule getRealConstantRule() { | ||
1955 | return getRealConstantAccess().getRule(); | ||
1956 | } | ||
1957 | |||
1958 | //StringConstant: | ||
1959 | // stringValue=STRING; | ||
1960 | public StringConstantElements getStringConstantAccess() { | ||
1961 | return pStringConstant; | ||
1962 | } | ||
1963 | |||
1964 | public ParserRule getStringConstantRule() { | ||
1965 | return getStringConstantAccess().getRule(); | ||
1966 | } | ||
1967 | |||
1554 | //ScopeDeclaration: | 1968 | //ScopeDeclaration: |
1555 | // "scope" typeScopes+=TypeScope ("," typeScopes+=TypeScope)* "."; | 1969 | // "scope" typeScopes+=TypeScope ("," typeScopes+=TypeScope)* "."; |
1556 | public ScopeDeclarationElements getScopeDeclarationAccess() { | 1970 | public ScopeDeclarationElements getScopeDeclarationAccess() { |
@@ -1643,7 +2057,7 @@ public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarE | |||
1643 | return getQuotedOrUnquotedIdAccess().getRule(); | 2057 | return getQuotedOrUnquotedIdAccess().getRule(); |
1644 | } | 2058 | } |
1645 | 2059 | ||
1646 | //QualifiedName: | 2060 | //QualifiedName hidden(): |
1647 | // QUOTED_ID | Identifier ("::" Identifier)* ("::" QUOTED_ID)?; | 2061 | // QUOTED_ID | Identifier ("::" Identifier)* ("::" QUOTED_ID)?; |
1648 | public QualifiedNameElements getQualifiedNameAccess() { | 2062 | public QualifiedNameElements getQualifiedNameAccess() { |
1649 | return pQualifiedName; | 2063 | return pQualifiedName; |
@@ -1654,7 +2068,7 @@ public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarE | |||
1654 | } | 2068 | } |
1655 | 2069 | ||
1656 | //Identifier: | 2070 | //Identifier: |
1657 | // ID | "true" | "false"; | 2071 | // ID | "true" | "false" | "e" | "E"; |
1658 | public IdentifierElements getIdentifierAccess() { | 2072 | public IdentifierElements getIdentifierAccess() { |
1659 | return pIdentifier; | 2073 | return pIdentifier; |
1660 | } | 2074 | } |
@@ -1663,6 +2077,33 @@ public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarE | |||
1663 | return getIdentifierAccess().getRule(); | 2077 | return getIdentifierAccess().getRule(); |
1664 | } | 2078 | } |
1665 | 2079 | ||
2080 | //Integer returns ecore::EInt hidden(): | ||
2081 | // "-"? INT; | ||
2082 | public IntegerElements getIntegerAccess() { | ||
2083 | return pInteger; | ||
2084 | } | ||
2085 | |||
2086 | public ParserRule getIntegerRule() { | ||
2087 | return getIntegerAccess().getRule(); | ||
2088 | } | ||
2089 | |||
2090 | //Real returns ecore::EDouble hidden(): | ||
2091 | // "-"? INT ("." INT | ("." INT)? ("e" | "E") ("-" | "+")? INT); | ||
2092 | public RealElements getRealAccess() { | ||
2093 | return pReal; | ||
2094 | } | ||
2095 | |||
2096 | public ParserRule getRealRule() { | ||
2097 | return getRealAccess().getRule(); | ||
2098 | } | ||
2099 | |||
2100 | //@Override | ||
2101 | //terminal ID: | ||
2102 | // ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; | ||
2103 | public TerminalRule getIDRule() { | ||
2104 | return tID; | ||
2105 | } | ||
2106 | |||
1666 | //@Override | 2107 | //@Override |
1667 | //terminal STRING: | 2108 | //terminal STRING: |
1668 | // '"' ('\\' . /* 'b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\' */ | !('\\' | '"'))* '"'; | 2109 | // '"' ('\\' . /* 'b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\' */ | !('\\' | '"'))* '"'; |
@@ -1678,16 +2119,11 @@ public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarE | |||
1678 | 2119 | ||
1679 | //@Override | 2120 | //@Override |
1680 | //terminal SL_COMMENT: | 2121 | //terminal SL_COMMENT: |
1681 | // ('%' | '//') !('\n'|'\r')* ('\r'? '\n')?; | 2122 | // ('%' | '//') !('\n' | '\r')* ('\r'? '\n')?; |
1682 | public TerminalRule getSL_COMMENTRule() { | 2123 | public TerminalRule getSL_COMMENTRule() { |
1683 | return tSL_COMMENT; | 2124 | return tSL_COMMENT; |
1684 | } | 2125 | } |
1685 | 2126 | ||
1686 | //terminal ID: '^'?('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; | ||
1687 | public TerminalRule getIDRule() { | ||
1688 | return gaTerminals.getIDRule(); | ||
1689 | } | ||
1690 | |||
1691 | //terminal INT returns ecore::EInt: ('0'..'9')+; | 2127 | //terminal INT returns ecore::EInt: ('0'..'9')+; |
1692 | public TerminalRule getINTRule() { | 2128 | public TerminalRule getINTRule() { |
1693 | return gaTerminals.getINTRule(); | 2129 | return gaTerminals.getINTRule(); |